cpp/gen/fasttest_gen.cpp#

    1//
    2// cpp/gen/fasttest_gen.cpp
    3// Generated by AMC
    4//
    5// Copyright (C) 2008-2013 AlgoEngineering LLC
    6// Copyright (C) 2013-2019 NYSE | Intercontinental Exchange
    7// Copyright (C) 2020-2023 Astra
    8// Copyright (C) 2023 AlgoRND
    9//
   10// This source code constitutes confidential information and trade secrets
   11// of AlgoRND. Unauthorized copying, distribution or sharing of this file,
   12// via any medium, is strictly prohibited.
   13//
   14
   15
   16#include "include/algo.h"  // hard-coded include
   17#include "include/gen/fasttest_gen.h"
   18#include "include/gen/fasttest_gen.inl.h"
   19#include "include/gen/algo_gen.h"
   20#include "include/gen/algo_gen.inl.h"
   21//#pragma endinclude
   22namespace fasttest { // gen:ns_print_proto
   23    // func:fasttest.BVCopyNull.Value60.ReadStrptrMaybe
   24    static bool          Value60_ReadStrptrMaybe(fasttest::BVCopyNull &parent, algo::strptr in_str) __attribute__((nothrow));
   25    // func:fasttest.BVCopyOpt.Value59.ReadStrptrMaybe
   26    static bool          Value59_ReadStrptrMaybe(fasttest::BVCopyOpt &parent, algo::strptr in_str) __attribute__((nothrow));
   27    // func:fasttest.BVDfltNull.Value.ReadStrptrMaybe
   28    static bool          Value_ReadStrptrMaybe(fasttest::BVDfltNull &parent, algo::strptr in_str) __attribute__((nothrow));
   29    // func:fasttest.BVDfltOpt.Value.ReadStrptrMaybe
   30    static bool          Value_ReadStrptrMaybe(fasttest::BVDfltOpt &parent, algo::strptr in_str) __attribute__((nothrow));
   31    // func:fasttest.BVNoneOpt.Value.ReadStrptrMaybe
   32    static bool          Value_ReadStrptrMaybe(fasttest::BVNoneOpt &parent, algo::strptr in_str) __attribute__((nothrow));
   33    // func:fasttest.SampleSet.prima.ReadStrptrMaybe
   34    static bool          prima_ReadStrptrMaybe(fasttest::SampleSet &parent, algo::strptr in_str) __attribute__((nothrow));
   35    // func:fasttest.SampleSet.secunda.ReadStrptrMaybe
   36    static bool          secunda_ReadStrptrMaybe(fasttest::SampleSet &parent, algo::strptr in_str) __attribute__((nothrow));
   37    // func:fasttest.SampleSet.tertia.ReadStrptrMaybe
   38    static bool          tertia_ReadStrptrMaybe(fasttest::SampleSet &parent, algo::strptr in_str) __attribute__((nothrow));
   39    // func:fasttest.GroupSgmOpt.OptSgmGrp.ReadStrptrMaybe
   40    static bool          OptSgmGrp_ReadStrptrMaybe(fasttest::GroupSgmOpt &parent, algo::strptr in_str) __attribute__((nothrow));
   41    // func:fasttest.GroupTrvOpt.OptTrvGrp.ReadStrptrMaybe
   42    static bool          OptTrvGrp_ReadStrptrMaybe(fasttest::GroupTrvOpt &parent, algo::strptr in_str) __attribute__((nothrow));
   43    // func:fasttest.I32CopyNull.Value51.ReadStrptrMaybe
   44    static bool          Value51_ReadStrptrMaybe(fasttest::I32CopyNull &parent, algo::strptr in_str) __attribute__((nothrow));
   45    // func:fasttest.I32CopyOpt.Value50.ReadStrptrMaybe
   46    static bool          Value50_ReadStrptrMaybe(fasttest::I32CopyOpt &parent, algo::strptr in_str) __attribute__((nothrow));
   47    // func:fasttest.I32DeltaNull.Value68.ReadStrptrMaybe
   48    static bool          Value68_ReadStrptrMaybe(fasttest::I32DeltaNull &parent, algo::strptr in_str) __attribute__((nothrow));
   49    // func:fasttest.I32DeltaOpt.Value67.ReadStrptrMaybe
   50    static bool          Value67_ReadStrptrMaybe(fasttest::I32DeltaOpt &parent, algo::strptr in_str) __attribute__((nothrow));
   51    // func:fasttest.I32DfltNull.Value.ReadStrptrMaybe
   52    static bool          Value_ReadStrptrMaybe(fasttest::I32DfltNull &parent, algo::strptr in_str) __attribute__((nothrow));
   53    // func:fasttest.I32DfltOpt.Value.ReadStrptrMaybe
   54    static bool          Value_ReadStrptrMaybe(fasttest::I32DfltOpt &parent, algo::strptr in_str) __attribute__((nothrow));
   55    // func:fasttest.I32IncrNull.Value100.ReadStrptrMaybe
   56    static bool          Value100_ReadStrptrMaybe(fasttest::I32IncrNull &parent, algo::strptr in_str) __attribute__((nothrow));
   57    // func:fasttest.I32IncrOpt.Value99.ReadStrptrMaybe
   58    static bool          Value99_ReadStrptrMaybe(fasttest::I32IncrOpt &parent, algo::strptr in_str) __attribute__((nothrow));
   59    // func:fasttest.I32NoneOpt.Value.ReadStrptrMaybe
   60    static bool          Value_ReadStrptrMaybe(fasttest::I32NoneOpt &parent, algo::strptr in_str) __attribute__((nothrow));
   61    // func:fasttest.SclCopyNull.Value63.ReadStrptrMaybe
   62    static bool          Value63_ReadStrptrMaybe(fasttest::SclCopyNull &parent, algo::strptr in_str) __attribute__((nothrow));
   63    // func:fasttest.SclCopyOpt.Value62.ReadStrptrMaybe
   64    static bool          Value62_ReadStrptrMaybe(fasttest::SclCopyOpt &parent, algo::strptr in_str) __attribute__((nothrow));
   65    // func:fasttest.SclDeltaNull.Value84.ReadStrptrMaybe
   66    static bool          Value84_ReadStrptrMaybe(fasttest::SclDeltaNull &parent, algo::strptr in_str) __attribute__((nothrow));
   67    // func:fasttest.SclDeltaOpt.Value83.ReadStrptrMaybe
   68    static bool          Value83_ReadStrptrMaybe(fasttest::SclDeltaOpt &parent, algo::strptr in_str) __attribute__((nothrow));
   69    // func:fasttest.SclDfltNull.Value.ReadStrptrMaybe
   70    static bool          Value_ReadStrptrMaybe(fasttest::SclDfltNull &parent, algo::strptr in_str) __attribute__((nothrow));
   71    // func:fasttest.SclDfltOpt.Value.ReadStrptrMaybe
   72    static bool          Value_ReadStrptrMaybe(fasttest::SclDfltOpt &parent, algo::strptr in_str) __attribute__((nothrow));
   73    // func:fasttest.SclNoneOpt.Value.ReadStrptrMaybe
   74    static bool          Value_ReadStrptrMaybe(fasttest::SclNoneOpt &parent, algo::strptr in_str) __attribute__((nothrow));
   75    // func:fasttest.SeqTrvLenConstOpt.TrvSeqLenConstOpt.ReadStrptrMaybe
   76    static bool          TrvSeqLenConstOpt_ReadStrptrMaybe(fasttest::SeqTrvLenConstOpt &parent, algo::strptr in_str) __attribute__((nothrow));
   77    // func:fasttest.StrCopyNull.Value57.ReadStrptrMaybe
   78    static bool          Value57_ReadStrptrMaybe(fasttest::StrCopyNull &parent, algo::strptr in_str) __attribute__((nothrow));
   79    // func:fasttest.StrCopyOpt.Value56.ReadStrptrMaybe
   80    static bool          Value56_ReadStrptrMaybe(fasttest::StrCopyOpt &parent, algo::strptr in_str) __attribute__((nothrow));
   81    // func:fasttest.StrDfltNull.Value.ReadStrptrMaybe
   82    static bool          Value_ReadStrptrMaybe(fasttest::StrDfltNull &parent, algo::strptr in_str) __attribute__((nothrow));
   83    // func:fasttest.StrDfltOpt.Value.ReadStrptrMaybe
   84    static bool          Value_ReadStrptrMaybe(fasttest::StrDfltOpt &parent, algo::strptr in_str) __attribute__((nothrow));
   85    // func:fasttest.StrNoneOpt.Value.ReadStrptrMaybe
   86    static bool          Value_ReadStrptrMaybe(fasttest::StrNoneOpt &parent, algo::strptr in_str) __attribute__((nothrow));
   87    // func:fasttest.U32CopyNull.Value54.ReadStrptrMaybe
   88    static bool          Value54_ReadStrptrMaybe(fasttest::U32CopyNull &parent, algo::strptr in_str) __attribute__((nothrow));
   89    // func:fasttest.U32CopyOpt.Value53.ReadStrptrMaybe
   90    static bool          Value53_ReadStrptrMaybe(fasttest::U32CopyOpt &parent, algo::strptr in_str) __attribute__((nothrow));
   91    // func:fasttest.U32DeltaNull.Value72.ReadStrptrMaybe
   92    static bool          Value72_ReadStrptrMaybe(fasttest::U32DeltaNull &parent, algo::strptr in_str) __attribute__((nothrow));
   93    // func:fasttest.U32DeltaOpt.Value71.ReadStrptrMaybe
   94    static bool          Value71_ReadStrptrMaybe(fasttest::U32DeltaOpt &parent, algo::strptr in_str) __attribute__((nothrow));
   95    // func:fasttest.U32DfltNull.Value.ReadStrptrMaybe
   96    static bool          Value_ReadStrptrMaybe(fasttest::U32DfltNull &parent, algo::strptr in_str) __attribute__((nothrow));
   97    // func:fasttest.U32DfltOpt.Value.ReadStrptrMaybe
   98    static bool          Value_ReadStrptrMaybe(fasttest::U32DfltOpt &parent, algo::strptr in_str) __attribute__((nothrow));
   99    // func:fasttest.U32IncrNull.Value104.ReadStrptrMaybe
  100    static bool          Value104_ReadStrptrMaybe(fasttest::U32IncrNull &parent, algo::strptr in_str) __attribute__((nothrow));
  101    // func:fasttest.U32IncrOpt.Value103.ReadStrptrMaybe
  102    static bool          Value103_ReadStrptrMaybe(fasttest::U32IncrOpt &parent, algo::strptr in_str) __attribute__((nothrow));
  103    // func:fasttest.U32NoneOpt.Value.ReadStrptrMaybe
  104    static bool          Value_ReadStrptrMaybe(fasttest::U32NoneOpt &parent, algo::strptr in_str) __attribute__((nothrow));
  105    // func:fasttest...SizeCheck
  106    static void          SizeCheck();
  107} // gen:ns_print_proto
  108
  109// --- fasttest.BVConst.base.CopyOut
  110// Copy fields out of row
  111void fasttest::parent_CopyOut(fasttest::BVConst &row, fasttest::TemplateHeader &out) {
  112    // length: field value is computed
  113    // id: field value is computed
  114    (void)row;//only to avoid -Wunused-parameter
  115    (void)out;//only to avoid -Wunused-parameter
  116}
  117
  118// --- fasttest.BVConst..ReadFieldMaybe
  119bool fasttest::BVConst_ReadFieldMaybe(fasttest::BVConst& parent, algo::strptr field, algo::strptr strval) {
  120    bool retval = true;
  121    fasttest::FieldId field_id;
  122    (void)value_SetStrptrMaybe(field_id,field);
  123    switch(field_id) {
  124        case fasttest_FieldId_base: {
  125            retval = false;
  126            break;
  127        }
  128        case fasttest_FieldId_length: {
  129            retval = false;
  130            break;
  131        }
  132        case fasttest_FieldId_id: {
  133            retval = false;
  134            break;
  135        }
  136        case fasttest_FieldId_Value: {
  137            retval = true;
  138            break;
  139        }
  140        default: break;
  141    }
  142    if (!retval) {
  143        algo_lib::AppendErrtext("attr",field);
  144    }
  145    (void)parent;//only to avoid -Wunused-parameter
  146    (void)strval;//only to avoid -Wunused-parameter
  147    return retval;
  148}
  149
  150// --- fasttest.BVConst..ReadStrptrMaybe
  151// Read fields of fasttest::BVConst from an ascii string.
  152// The format of the string is an ssim Tuple
  153bool fasttest::BVConst_ReadStrptrMaybe(fasttest::BVConst &parent, algo::strptr in_str) {
  154    bool retval = true;
  155    retval = algo::StripTypeTag(in_str, "fasttest.BVConst");
  156    ind_beg(algo::Attr_curs, attr, in_str) {
  157        retval = retval && BVConst_ReadFieldMaybe(parent, attr.name, attr.value);
  158    }ind_end;
  159    return retval;
  160}
  161
  162// --- fasttest.BVConst..Print
  163// print string representation of ROW to string STR
  164// cfmt:fasttest.BVConst.String  printfmt:Tuple
  165void fasttest::BVConst_Print(fasttest::BVConst& row, algo::cstring& str) {
  166    algo::tempstr temp;
  167    str << "fasttest.BVConst";
  168
  169    algo::strptr_Print(Value_Get(row), temp);
  170    PrintAttrSpaceReset(str,"Value", temp);
  171}
  172
  173// --- fasttest.BVConst..FastEncode
  174void fasttest::BVConst_FastEncode(algo::ByteAry& buf, FastState& state, fasttest::BVConst& parent) {
  175    int index = ary_N(buf);
  176    u64 pmap(0);
  177    if (!tid_AssignedQ(state) || parent.id != state.tid) {
  178        lib_fast::EncodeUnsigned(buf,parent.id,false);
  179        lib_fast::SetPmapBit(pmap,0);
  180    }
  181    tid_SetAssigned(state);
  182    state.tid = parent.id;
  183    // Value byteVector constant mandatory
  184    lib_fast::InsertPmap(buf,index,pmap);
  185}
  186
  187// --- fasttest.BVConst..FastDecode
  188bool fasttest::BVConst_FastDecode(algo::memptr& from, u64 pmap, FastState& state, fasttest::BVConst& parent) {
  189    bool ok = true;
  190    // Value byteVector constant mandatory
  191    if (ok) {
  192    }
  193    (void)from;//only to avoid -Wunused-parameter
  194    (void)pmap;//only to avoid -Wunused-parameter
  195    (void)state;//only to avoid -Wunused-parameter
  196    (void)parent;//only to avoid -Wunused-parameter
  197    return ok;
  198}
  199
  200// --- fasttest.BVConst..FixEncode
  201void fasttest::BVConst_FixEncode(cstring& buf, fasttest::BVConst& parent, char soh) {
  202    buf << "1=" << Value_Get(parent) << soh;
  203}
  204
  205// --- fasttest.BVConstOpt.base.CopyOut
  206// Copy fields out of row
  207void fasttest::parent_CopyOut(fasttest::BVConstOpt &row, fasttest::TemplateHeader &out) {
  208    // length: field value is computed
  209    // id: field value is computed
  210    (void)row;//only to avoid -Wunused-parameter
  211    (void)out;//only to avoid -Wunused-parameter
  212}
  213
  214// --- fasttest.BVConstOpt.pmask_bitcurs.Next
  215// proceed to next item
  216void fasttest::BVConstOpt_pmask_bitcurs_Next(BVConstOpt_pmask_bitcurs &curs) {
  217    ++curs.bit;
  218    int index = curs.bit / 32;
  219    int offset = curs.bit % 32;
  220    for (; index < curs.n_elems; ++index, offset = 0) {
  221        u64 rest = curs.elems[index] >> offset;
  222        if (rest) {
  223            offset += algo::u64_BitScanForward(rest);
  224            break;
  225        }
  226    }
  227    curs.bit = index * 32 + offset;
  228}
  229
  230// --- fasttest.BVConstOpt..ReadFieldMaybe
  231bool fasttest::BVConstOpt_ReadFieldMaybe(fasttest::BVConstOpt& parent, algo::strptr field, algo::strptr strval) {
  232    bool retval = true;
  233    fasttest::FieldId field_id;
  234    (void)value_SetStrptrMaybe(field_id,field);
  235    switch(field_id) {
  236        case fasttest_FieldId_base: {
  237            retval = false;
  238            break;
  239        }
  240        case fasttest_FieldId_length: {
  241            retval = false;
  242            break;
  243        }
  244        case fasttest_FieldId_id: {
  245            retval = false;
  246            break;
  247        }
  248        case fasttest_FieldId_pmask: {
  249            retval = false;
  250            break;
  251        }
  252        case fasttest_FieldId_Value: {
  253            retval = true;
  254            if (retval) {
  255                pmask_qSetBit(parent, 0);
  256            }
  257            break;
  258        }
  259        default: break;
  260    }
  261    if (!retval) {
  262        algo_lib::AppendErrtext("attr",field);
  263    }
  264    (void)strval;//only to avoid -Wunused-parameter
  265    return retval;
  266}
  267
  268// --- fasttest.BVConstOpt..ReadStrptrMaybe
  269// Read fields of fasttest::BVConstOpt from an ascii string.
  270// The format of the string is an ssim Tuple
  271bool fasttest::BVConstOpt_ReadStrptrMaybe(fasttest::BVConstOpt &parent, algo::strptr in_str) {
  272    bool retval = true;
  273    retval = algo::StripTypeTag(in_str, "fasttest.BVConstOpt");
  274    ind_beg(algo::Attr_curs, attr, in_str) {
  275        retval = retval && BVConstOpt_ReadFieldMaybe(parent, attr.name, attr.value);
  276    }ind_end;
  277    return retval;
  278}
  279
  280// --- fasttest.BVConstOpt..Print
  281// print string representation of ROW to string STR
  282// cfmt:fasttest.BVConstOpt.String  printfmt:Tuple
  283void fasttest::BVConstOpt_Print(fasttest::BVConstOpt& row, algo::cstring& str) {
  284    algo::tempstr temp;
  285    str << "fasttest.BVConstOpt";
  286
  287    if (Value_PresentQ(row)) {
  288        algo::strptr_Print(Value_Get(row), temp);
  289        PrintAttrSpaceReset(str,"Value", temp);
  290    }
  291}
  292
  293// --- fasttest.BVConstOpt..FastEncode
  294void fasttest::BVConstOpt_FastEncode(algo::ByteAry& buf, FastState& state, fasttest::BVConstOpt& parent) {
  295    int index = ary_N(buf);
  296    u64 pmap(0);
  297    if (!tid_AssignedQ(state) || parent.id != state.tid) {
  298        lib_fast::EncodeUnsigned(buf,parent.id,false);
  299        lib_fast::SetPmapBit(pmap,0);
  300    }
  301    tid_SetAssigned(state);
  302    state.tid = parent.id;
  303    // Value byteVector constant optional
  304    if (Value_PresentQ(parent)) {
  305        lib_fast::SetPmapBit(pmap,1);
  306    }
  307    lib_fast::InsertPmap(buf,index,pmap);
  308}
  309
  310// --- fasttest.BVConstOpt..FastDecode
  311bool fasttest::BVConstOpt_FastDecode(algo::memptr& from, u64 pmap, FastState& state, fasttest::BVConstOpt& parent) {
  312    bool ok = true;
  313    // Value byteVector constant optional
  314    if (ok) {
  315        bool prs = lib_fast::GetPmapBit(pmap,1);
  316        pmask_qSetBitVal(parent,Value_Present_GetBit(parent),prs);
  317    }
  318    (void)from;//only to avoid -Wunused-parameter
  319    (void)state;//only to avoid -Wunused-parameter
  320    return ok;
  321}
  322
  323// --- fasttest.BVConstOpt..FixEncode
  324void fasttest::BVConstOpt_FixEncode(cstring& buf, fasttest::BVConstOpt& parent, char soh) {
  325    if (Value_PresentQ(parent)) {
  326        buf << "1=" << Value_Get(parent) << soh;
  327    }
  328}
  329
  330// --- fasttest.BVCopy.base.CopyOut
  331// Copy fields out of row
  332void fasttest::parent_CopyOut(fasttest::BVCopy &row, fasttest::TemplateHeader &out) {
  333    // length: field value is computed
  334    // id: field value is computed
  335    (void)row;//only to avoid -Wunused-parameter
  336    (void)out;//only to avoid -Wunused-parameter
  337}
  338
  339// --- fasttest.BVCopy..ReadFieldMaybe
  340bool fasttest::BVCopy_ReadFieldMaybe(fasttest::BVCopy& parent, algo::strptr field, algo::strptr strval) {
  341    bool retval = true;
  342    fasttest::FieldId field_id;
  343    (void)value_SetStrptrMaybe(field_id,field);
  344    switch(field_id) {
  345        case fasttest_FieldId_base: {
  346            retval = false;
  347            break;
  348        }
  349        case fasttest_FieldId_length: {
  350            retval = false;
  351            break;
  352        }
  353        case fasttest_FieldId_id: {
  354            retval = false;
  355            break;
  356        }
  357        case fasttest_FieldId_Value58: {
  358            retval = algo::Smallstr30_ReadStrptrMaybe(parent.Value58, strval);
  359            break;
  360        }
  361        default: break;
  362    }
  363    if (!retval) {
  364        algo_lib::AppendErrtext("attr",field);
  365    }
  366    return retval;
  367}
  368
  369// --- fasttest.BVCopy..ReadStrptrMaybe
  370// Read fields of fasttest::BVCopy from an ascii string.
  371// The format of the string is an ssim Tuple
  372bool fasttest::BVCopy_ReadStrptrMaybe(fasttest::BVCopy &parent, algo::strptr in_str) {
  373    bool retval = true;
  374    retval = algo::StripTypeTag(in_str, "fasttest.BVCopy");
  375    ind_beg(algo::Attr_curs, attr, in_str) {
  376        retval = retval && BVCopy_ReadFieldMaybe(parent, attr.name, attr.value);
  377    }ind_end;
  378    return retval;
  379}
  380
  381// --- fasttest.BVCopy..Print
  382// print string representation of ROW to string STR
  383// cfmt:fasttest.BVCopy.String  printfmt:Tuple
  384void fasttest::BVCopy_Print(fasttest::BVCopy& row, algo::cstring& str) {
  385    algo::tempstr temp;
  386    str << "fasttest.BVCopy";
  387
  388    algo::Smallstr30_Print(row.Value58, temp);
  389    PrintAttrSpaceReset(str,"Value58", temp);
  390}
  391
  392// --- fasttest.BVCopy..FastEncode
  393void fasttest::BVCopy_FastEncode(algo::ByteAry& buf, FastState& state, fasttest::BVCopy& parent) {
  394    int index = ary_N(buf);
  395    u64 pmap(0);
  396    if (!tid_AssignedQ(state) || parent.id != state.tid) {
  397        lib_fast::EncodeUnsigned(buf,parent.id,false);
  398        lib_fast::SetPmapBit(pmap,0);
  399    }
  400    tid_SetAssigned(state);
  401    state.tid = parent.id;
  402    // Value58 byteVector copy mandatory
  403    if (Value58_AssignedQ(state) ? parent.Value58 != state.Value58 : parent.Value58 != "B58") {
  404        lib_fast::EncodeByteVector(buf,parent.Value58,false);
  405        lib_fast::SetPmapBit(pmap,1);
  406    }
  407    state.Value58 = parent.Value58;
  408    Value58_SetAssigned(state);
  409    lib_fast::InsertPmap(buf,index,pmap);
  410}
  411
  412// --- fasttest.BVCopy..FastDecode
  413bool fasttest::BVCopy_FastDecode(algo::memptr& from, u64 pmap, FastState& state, fasttest::BVCopy& parent) {
  414    bool ok = true;
  415    // Value58 byteVector copy mandatory
  416    if (ok) {
  417        bool prs = lib_fast::GetPmapBit(pmap,1);
  418        if (prs) {
  419            ok = lib_fast::DecodeByteVector(from,parent.Value58,false);
  420            if (!ok) {
  421                state.error << "fasttest.BVCopy.Value58: bad ByteVector" << eol;
  422            }
  423        } else if (Value58_AssignedQ(state)) {
  424            parent.Value58 = state.Value58;
  425        } else {
  426            parent.Value58 = "B58";
  427        }
  428        Value58_SetAssigned(state);
  429        state.Value58 = parent.Value58;
  430    }
  431    return ok;
  432}
  433
  434// --- fasttest.BVCopy..FixEncode
  435void fasttest::BVCopy_FixEncode(cstring& buf, fasttest::BVCopy& parent, char soh) {
  436    buf << "1=" << parent.Value58 << soh;
  437}
  438
  439// --- fasttest.BVCopyNull.base.CopyOut
  440// Copy fields out of row
  441void fasttest::parent_CopyOut(fasttest::BVCopyNull &row, fasttest::TemplateHeader &out) {
  442    // length: field value is computed
  443    // id: field value is computed
  444    (void)row;//only to avoid -Wunused-parameter
  445    (void)out;//only to avoid -Wunused-parameter
  446}
  447
  448// --- fasttest.BVCopyNull.Value60.ReadStrptrMaybe
  449inline static bool fasttest::Value60_ReadStrptrMaybe(fasttest::BVCopyNull &parent, algo::strptr in_str) {
  450    bool retval = true;
  451    algo::Smallstr30 Value60_tmp;
  452    retval = algo::Smallstr30_ReadStrptrMaybe(Value60_tmp, in_str);
  453    if (retval) {
  454        Value60_Set(parent, Value60_tmp);
  455    }
  456    return retval;
  457}
  458
  459// --- fasttest.BVCopyNull.pmask_bitcurs.Next
  460// proceed to next item
  461void fasttest::BVCopyNull_pmask_bitcurs_Next(BVCopyNull_pmask_bitcurs &curs) {
  462    ++curs.bit;
  463    int index = curs.bit / 32;
  464    int offset = curs.bit % 32;
  465    for (; index < curs.n_elems; ++index, offset = 0) {
  466        u64 rest = curs.elems[index] >> offset;
  467        if (rest) {
  468            offset += algo::u64_BitScanForward(rest);
  469            break;
  470        }
  471    }
  472    curs.bit = index * 32 + offset;
  473}
  474
  475// --- fasttest.BVCopyNull..ReadFieldMaybe
  476bool fasttest::BVCopyNull_ReadFieldMaybe(fasttest::BVCopyNull& parent, algo::strptr field, algo::strptr strval) {
  477    bool retval = true;
  478    fasttest::FieldId field_id;
  479    (void)value_SetStrptrMaybe(field_id,field);
  480    switch(field_id) {
  481        case fasttest_FieldId_base: {
  482            retval = false;
  483            break;
  484        }
  485        case fasttest_FieldId_length: {
  486            retval = false;
  487            break;
  488        }
  489        case fasttest_FieldId_id: {
  490            retval = false;
  491            break;
  492        }
  493        case fasttest_FieldId_pmask: {
  494            retval = false;
  495            break;
  496        }
  497        case fasttest_FieldId_Value60: {
  498            retval = Value60_ReadStrptrMaybe(parent, strval);
  499            if (retval) {
  500                pmask_qSetBit(parent, 0);
  501            }
  502            break;
  503        }
  504        default: break;
  505    }
  506    if (!retval) {
  507        algo_lib::AppendErrtext("attr",field);
  508    }
  509    return retval;
  510}
  511
  512// --- fasttest.BVCopyNull..ReadStrptrMaybe
  513// Read fields of fasttest::BVCopyNull from an ascii string.
  514// The format of the string is an ssim Tuple
  515bool fasttest::BVCopyNull_ReadStrptrMaybe(fasttest::BVCopyNull &parent, algo::strptr in_str) {
  516    bool retval = true;
  517    retval = algo::StripTypeTag(in_str, "fasttest.BVCopyNull");
  518    ind_beg(algo::Attr_curs, attr, in_str) {
  519        retval = retval && BVCopyNull_ReadFieldMaybe(parent, attr.name, attr.value);
  520    }ind_end;
  521    return retval;
  522}
  523
  524// --- fasttest.BVCopyNull..Print
  525// print string representation of ROW to string STR
  526// cfmt:fasttest.BVCopyNull.String  printfmt:Tuple
  527void fasttest::BVCopyNull_Print(fasttest::BVCopyNull& row, algo::cstring& str) {
  528    algo::tempstr temp;
  529    str << "fasttest.BVCopyNull";
  530
  531    if (Value60_PresentQ(row)) {
  532        algo::Smallstr30_Print(row.Value60, temp);
  533        PrintAttrSpaceReset(str,"Value60", temp);
  534    }
  535}
  536
  537// --- fasttest.BVCopyNull..FastEncode
  538void fasttest::BVCopyNull_FastEncode(algo::ByteAry& buf, FastState& state, fasttest::BVCopyNull& parent) {
  539    int index = ary_N(buf);
  540    u64 pmap(0);
  541    if (!tid_AssignedQ(state) || parent.id != state.tid) {
  542        lib_fast::EncodeUnsigned(buf,parent.id,false);
  543        lib_fast::SetPmapBit(pmap,0);
  544    }
  545    tid_SetAssigned(state);
  546    state.tid = parent.id;
  547    // Value60 byteVector copy optional
  548    if (Value60_PresentQ(parent)) {
  549        if (!Value60_AssignedQ(state) || !Value60_PresentQ(state) ||  parent.Value60 != state.Value60 ) {
  550            lib_fast::EncodeByteVector(buf,parent.Value60,true);
  551            lib_fast::SetPmapBit(pmap,1);
  552        }
  553    } else {
  554        if (Value60_AssignedQ(state)) {
  555            lib_fast::EncodeNull(buf);
  556            lib_fast::SetPmapBit(pmap,1);
  557        }
  558    }
  559    state.Value60 = parent.Value60;
  560    present_qSetBitVal(state,Value60_Present_GetBit(state),Value60_PresentQ(parent));
  561    Value60_SetAssigned(state);
  562    lib_fast::InsertPmap(buf,index,pmap);
  563}
  564
  565// --- fasttest.BVCopyNull..FastDecode
  566bool fasttest::BVCopyNull_FastDecode(algo::memptr& from, u64 pmap, FastState& state, fasttest::BVCopyNull& parent) {
  567    bool ok = true;
  568    // Value60 byteVector copy optional
  569    if (ok) {
  570        bool prs = lib_fast::GetPmapBit(pmap,1);
  571        if (prs) {
  572            prs = !lib_fast::DecodeNull(from);
  573            if (prs) {
  574                ok = lib_fast::DecodeByteVector(from,parent.Value60,true);
  575                if (!ok) {
  576                    state.error << "fasttest.BVCopyNull.Value60: bad ByteVector" << eol;
  577                }
  578            }
  579        } else if (Value60_AssignedQ(state)) {
  580            parent.Value60 = state.Value60;
  581            prs = Value60_PresentQ(state);
  582        } else {
  583            prs = false;
  584        }
  585        pmask_qSetBitVal(parent,Value60_Present_GetBit(parent),prs);
  586        Value60_SetAssigned(state);
  587        present_qSetBitVal(state,Value60_Present_GetBit(state),prs);
  588        state.Value60 = parent.Value60;
  589    }
  590    return ok;
  591}
  592
  593// --- fasttest.BVCopyNull..FixEncode
  594void fasttest::BVCopyNull_FixEncode(cstring& buf, fasttest::BVCopyNull& parent, char soh) {
  595    if (Value60_PresentQ(parent)) {
  596        buf << "1=" << parent.Value60 << soh;
  597    }
  598}
  599
  600// --- fasttest.BVCopyOpt.base.CopyOut
  601// Copy fields out of row
  602void fasttest::parent_CopyOut(fasttest::BVCopyOpt &row, fasttest::TemplateHeader &out) {
  603    // length: field value is computed
  604    // id: field value is computed
  605    (void)row;//only to avoid -Wunused-parameter
  606    (void)out;//only to avoid -Wunused-parameter
  607}
  608
  609// --- fasttest.BVCopyOpt.Value59.ReadStrptrMaybe
  610inline static bool fasttest::Value59_ReadStrptrMaybe(fasttest::BVCopyOpt &parent, algo::strptr in_str) {
  611    bool retval = true;
  612    algo::Smallstr30 Value59_tmp;
  613    retval = algo::Smallstr30_ReadStrptrMaybe(Value59_tmp, in_str);
  614    if (retval) {
  615        Value59_Set(parent, Value59_tmp);
  616    }
  617    return retval;
  618}
  619
  620// --- fasttest.BVCopyOpt.pmask_bitcurs.Next
  621// proceed to next item
  622void fasttest::BVCopyOpt_pmask_bitcurs_Next(BVCopyOpt_pmask_bitcurs &curs) {
  623    ++curs.bit;
  624    int index = curs.bit / 32;
  625    int offset = curs.bit % 32;
  626    for (; index < curs.n_elems; ++index, offset = 0) {
  627        u64 rest = curs.elems[index] >> offset;
  628        if (rest) {
  629            offset += algo::u64_BitScanForward(rest);
  630            break;
  631        }
  632    }
  633    curs.bit = index * 32 + offset;
  634}
  635
  636// --- fasttest.BVCopyOpt..ReadFieldMaybe
  637bool fasttest::BVCopyOpt_ReadFieldMaybe(fasttest::BVCopyOpt& parent, algo::strptr field, algo::strptr strval) {
  638    bool retval = true;
  639    fasttest::FieldId field_id;
  640    (void)value_SetStrptrMaybe(field_id,field);
  641    switch(field_id) {
  642        case fasttest_FieldId_base: {
  643            retval = false;
  644            break;
  645        }
  646        case fasttest_FieldId_length: {
  647            retval = false;
  648            break;
  649        }
  650        case fasttest_FieldId_id: {
  651            retval = false;
  652            break;
  653        }
  654        case fasttest_FieldId_pmask: {
  655            retval = false;
  656            break;
  657        }
  658        case fasttest_FieldId_Value59: {
  659            retval = Value59_ReadStrptrMaybe(parent, strval);
  660            if (retval) {
  661                pmask_qSetBit(parent, 0);
  662            }
  663            break;
  664        }
  665        default: break;
  666    }
  667    if (!retval) {
  668        algo_lib::AppendErrtext("attr",field);
  669    }
  670    return retval;
  671}
  672
  673// --- fasttest.BVCopyOpt..ReadStrptrMaybe
  674// Read fields of fasttest::BVCopyOpt from an ascii string.
  675// The format of the string is an ssim Tuple
  676bool fasttest::BVCopyOpt_ReadStrptrMaybe(fasttest::BVCopyOpt &parent, algo::strptr in_str) {
  677    bool retval = true;
  678    retval = algo::StripTypeTag(in_str, "fasttest.BVCopyOpt");
  679    ind_beg(algo::Attr_curs, attr, in_str) {
  680        retval = retval && BVCopyOpt_ReadFieldMaybe(parent, attr.name, attr.value);
  681    }ind_end;
  682    return retval;
  683}
  684
  685// --- fasttest.BVCopyOpt..Print
  686// print string representation of ROW to string STR
  687// cfmt:fasttest.BVCopyOpt.String  printfmt:Tuple
  688void fasttest::BVCopyOpt_Print(fasttest::BVCopyOpt& row, algo::cstring& str) {
  689    algo::tempstr temp;
  690    str << "fasttest.BVCopyOpt";
  691
  692    if (Value59_PresentQ(row)) {
  693        algo::Smallstr30_Print(row.Value59, temp);
  694        PrintAttrSpaceReset(str,"Value59", temp);
  695    }
  696}
  697
  698// --- fasttest.BVCopyOpt..FastEncode
  699void fasttest::BVCopyOpt_FastEncode(algo::ByteAry& buf, FastState& state, fasttest::BVCopyOpt& parent) {
  700    int index = ary_N(buf);
  701    u64 pmap(0);
  702    if (!tid_AssignedQ(state) || parent.id != state.tid) {
  703        lib_fast::EncodeUnsigned(buf,parent.id,false);
  704        lib_fast::SetPmapBit(pmap,0);
  705    }
  706    tid_SetAssigned(state);
  707    state.tid = parent.id;
  708    // Value59 byteVector copy optional
  709    if (Value59_PresentQ(parent)) {
  710        if (Value59_AssignedQ(state) ? !Value59_PresentQ(state) || parent.Value59 != state.Value59 : parent.Value59 != "B59") {
  711            lib_fast::EncodeByteVector(buf,parent.Value59,true);
  712            lib_fast::SetPmapBit(pmap,1);
  713        }
  714    } else {
  715        if (Value59_AssignedQ(state) && Value59_PresentQ(state)) {
  716            lib_fast::EncodeNull(buf);
  717            lib_fast::SetPmapBit(pmap,1);
  718        }
  719    }
  720    state.Value59 = parent.Value59;
  721    present_qSetBitVal(state,Value59_Present_GetBit(state),Value59_PresentQ(parent));
  722    Value59_SetAssigned(state);
  723    lib_fast::InsertPmap(buf,index,pmap);
  724}
  725
  726// --- fasttest.BVCopyOpt..FastDecode
  727bool fasttest::BVCopyOpt_FastDecode(algo::memptr& from, u64 pmap, FastState& state, fasttest::BVCopyOpt& parent) {
  728    bool ok = true;
  729    // Value59 byteVector copy optional
  730    if (ok) {
  731        bool prs = lib_fast::GetPmapBit(pmap,1);
  732        if (prs) {
  733            prs = !lib_fast::DecodeNull(from);
  734            if (prs) {
  735                ok = lib_fast::DecodeByteVector(from,parent.Value59,true);
  736                if (!ok) {
  737                    state.error << "fasttest.BVCopyOpt.Value59: bad ByteVector" << eol;
  738                }
  739            }
  740        } else if (Value59_AssignedQ(state)) {
  741            parent.Value59 = state.Value59;
  742            prs = Value59_PresentQ(state);
  743        } else {
  744            parent.Value59 = "B59";
  745            prs = true;
  746        }
  747        pmask_qSetBitVal(parent,Value59_Present_GetBit(parent),prs);
  748        Value59_SetAssigned(state);
  749        present_qSetBitVal(state,Value59_Present_GetBit(state),prs);
  750        state.Value59 = parent.Value59;
  751    }
  752    return ok;
  753}
  754
  755// --- fasttest.BVCopyOpt..FixEncode
  756void fasttest::BVCopyOpt_FixEncode(cstring& buf, fasttest::BVCopyOpt& parent, char soh) {
  757    if (Value59_PresentQ(parent)) {
  758        buf << "1=" << parent.Value59 << soh;
  759    }
  760}
  761
  762// --- fasttest.BVDflt.base.CopyOut
  763// Copy fields out of row
  764void fasttest::parent_CopyOut(fasttest::BVDflt &row, fasttest::TemplateHeader &out) {
  765    // length: field value is computed
  766    // id: field value is computed
  767    (void)row;//only to avoid -Wunused-parameter
  768    (void)out;//only to avoid -Wunused-parameter
  769}
  770
  771// --- fasttest.BVDflt..ReadFieldMaybe
  772bool fasttest::BVDflt_ReadFieldMaybe(fasttest::BVDflt& parent, algo::strptr field, algo::strptr strval) {
  773    bool retval = true;
  774    fasttest::FieldId field_id;
  775    (void)value_SetStrptrMaybe(field_id,field);
  776    switch(field_id) {
  777        case fasttest_FieldId_base: {
  778            retval = false;
  779            break;
  780        }
  781        case fasttest_FieldId_length: {
  782            retval = false;
  783            break;
  784        }
  785        case fasttest_FieldId_id: {
  786            retval = false;
  787            break;
  788        }
  789        case fasttest_FieldId_Value: {
  790            retval = algo::Smallstr30_ReadStrptrMaybe(parent.Value, strval);
  791            break;
  792        }
  793        default: break;
  794    }
  795    if (!retval) {
  796        algo_lib::AppendErrtext("attr",field);
  797    }
  798    return retval;
  799}
  800
  801// --- fasttest.BVDflt..ReadStrptrMaybe
  802// Read fields of fasttest::BVDflt from an ascii string.
  803// The format of the string is an ssim Tuple
  804bool fasttest::BVDflt_ReadStrptrMaybe(fasttest::BVDflt &parent, algo::strptr in_str) {
  805    bool retval = true;
  806    retval = algo::StripTypeTag(in_str, "fasttest.BVDflt");
  807    ind_beg(algo::Attr_curs, attr, in_str) {
  808        retval = retval && BVDflt_ReadFieldMaybe(parent, attr.name, attr.value);
  809    }ind_end;
  810    return retval;
  811}
  812
  813// --- fasttest.BVDflt..Print
  814// print string representation of ROW to string STR
  815// cfmt:fasttest.BVDflt.String  printfmt:Tuple
  816void fasttest::BVDflt_Print(fasttest::BVDflt& row, algo::cstring& str) {
  817    algo::tempstr temp;
  818    str << "fasttest.BVDflt";
  819
  820    algo::Smallstr30_Print(row.Value, temp);
  821    PrintAttrSpaceReset(str,"Value", temp);
  822}
  823
  824// --- fasttest.BVDflt..FastEncode
  825void fasttest::BVDflt_FastEncode(algo::ByteAry& buf, FastState& state, fasttest::BVDflt& parent) {
  826    int index = ary_N(buf);
  827    u64 pmap(0);
  828    if (!tid_AssignedQ(state) || parent.id != state.tid) {
  829        lib_fast::EncodeUnsigned(buf,parent.id,false);
  830        lib_fast::SetPmapBit(pmap,0);
  831    }
  832    tid_SetAssigned(state);
  833    state.tid = parent.id;
  834    // Value byteVector default mandatory
  835    if (parent.Value != "B42") {
  836        lib_fast::EncodeByteVector(buf,parent.Value,false);
  837        lib_fast::SetPmapBit(pmap,1);
  838    }
  839    lib_fast::InsertPmap(buf,index,pmap);
  840}
  841
  842// --- fasttest.BVDflt..FastDecode
  843bool fasttest::BVDflt_FastDecode(algo::memptr& from, u64 pmap, FastState& state, fasttest::BVDflt& parent) {
  844    bool ok = true;
  845    // Value byteVector default mandatory
  846    if (ok) {
  847        bool prs = lib_fast::GetPmapBit(pmap,1);
  848        if (prs) {
  849            ok = lib_fast::DecodeByteVector(from,parent.Value,false);
  850            if (!ok) {
  851                state.error << "fasttest.BVDflt.Value: bad ByteVector" << eol;
  852            }
  853        } else {
  854            parent.Value = "B42";
  855        }
  856    }
  857    return ok;
  858}
  859
  860// --- fasttest.BVDflt..FixEncode
  861void fasttest::BVDflt_FixEncode(cstring& buf, fasttest::BVDflt& parent, char soh) {
  862    buf << "1=" << parent.Value << soh;
  863}
  864
  865// --- fasttest.BVDfltNull.base.CopyOut
  866// Copy fields out of row
  867void fasttest::parent_CopyOut(fasttest::BVDfltNull &row, fasttest::TemplateHeader &out) {
  868    // length: field value is computed
  869    // id: field value is computed
  870    (void)row;//only to avoid -Wunused-parameter
  871    (void)out;//only to avoid -Wunused-parameter
  872}
  873
  874// --- fasttest.BVDfltNull.Value.ReadStrptrMaybe
  875inline static bool fasttest::Value_ReadStrptrMaybe(fasttest::BVDfltNull &parent, algo::strptr in_str) {
  876    bool retval = true;
  877    algo::Smallstr30 Value_tmp;
  878    retval = algo::Smallstr30_ReadStrptrMaybe(Value_tmp, in_str);
  879    if (retval) {
  880        Value_Set(parent, Value_tmp);
  881    }
  882    return retval;
  883}
  884
  885// --- fasttest.BVDfltNull.pmask_bitcurs.Next
  886// proceed to next item
  887void fasttest::BVDfltNull_pmask_bitcurs_Next(BVDfltNull_pmask_bitcurs &curs) {
  888    ++curs.bit;
  889    int index = curs.bit / 32;
  890    int offset = curs.bit % 32;
  891    for (; index < curs.n_elems; ++index, offset = 0) {
  892        u64 rest = curs.elems[index] >> offset;
  893        if (rest) {
  894            offset += algo::u64_BitScanForward(rest);
  895            break;
  896        }
  897    }
  898    curs.bit = index * 32 + offset;
  899}
  900
  901// --- fasttest.BVDfltNull..ReadFieldMaybe
  902bool fasttest::BVDfltNull_ReadFieldMaybe(fasttest::BVDfltNull& parent, algo::strptr field, algo::strptr strval) {
  903    bool retval = true;
  904    fasttest::FieldId field_id;
  905    (void)value_SetStrptrMaybe(field_id,field);
  906    switch(field_id) {
  907        case fasttest_FieldId_base: {
  908            retval = false;
  909            break;
  910        }
  911        case fasttest_FieldId_length: {
  912            retval = false;
  913            break;
  914        }
  915        case fasttest_FieldId_id: {
  916            retval = false;
  917            break;
  918        }
  919        case fasttest_FieldId_pmask: {
  920            retval = false;
  921            break;
  922        }
  923        case fasttest_FieldId_Value: {
  924            retval = Value_ReadStrptrMaybe(parent, strval);
  925            if (retval) {
  926                pmask_qSetBit(parent, 0);
  927            }
  928            break;
  929        }
  930        default: break;
  931    }
  932    if (!retval) {
  933        algo_lib::AppendErrtext("attr",field);
  934    }
  935    return retval;
  936}
  937
  938// --- fasttest.BVDfltNull..ReadStrptrMaybe
  939// Read fields of fasttest::BVDfltNull from an ascii string.
  940// The format of the string is an ssim Tuple
  941bool fasttest::BVDfltNull_ReadStrptrMaybe(fasttest::BVDfltNull &parent, algo::strptr in_str) {
  942    bool retval = true;
  943    retval = algo::StripTypeTag(in_str, "fasttest.BVDfltNull");
  944    ind_beg(algo::Attr_curs, attr, in_str) {
  945        retval = retval && BVDfltNull_ReadFieldMaybe(parent, attr.name, attr.value);
  946    }ind_end;
  947    return retval;
  948}
  949
  950// --- fasttest.BVDfltNull..Print
  951// print string representation of ROW to string STR
  952// cfmt:fasttest.BVDfltNull.String  printfmt:Tuple
  953void fasttest::BVDfltNull_Print(fasttest::BVDfltNull& row, algo::cstring& str) {
  954    algo::tempstr temp;
  955    str << "fasttest.BVDfltNull";
  956
  957    if (Value_PresentQ(row)) {
  958        algo::Smallstr30_Print(row.Value, temp);
  959        PrintAttrSpaceReset(str,"Value", temp);
  960    }
  961}
  962
  963// --- fasttest.BVDfltNull..FastEncode
  964void fasttest::BVDfltNull_FastEncode(algo::ByteAry& buf, FastState& state, fasttest::BVDfltNull& parent) {
  965    int index = ary_N(buf);
  966    u64 pmap(0);
  967    if (!tid_AssignedQ(state) || parent.id != state.tid) {
  968        lib_fast::EncodeUnsigned(buf,parent.id,false);
  969        lib_fast::SetPmapBit(pmap,0);
  970    }
  971    tid_SetAssigned(state);
  972    state.tid = parent.id;
  973    // Value byteVector default optional
  974    if (Value_PresentQ(parent)) {
  975        lib_fast::EncodeByteVector(buf,parent.Value,true);
  976        lib_fast::SetPmapBit(pmap,1);
  977    }
  978    lib_fast::InsertPmap(buf,index,pmap);
  979}
  980
  981// --- fasttest.BVDfltNull..FastDecode
  982bool fasttest::BVDfltNull_FastDecode(algo::memptr& from, u64 pmap, FastState& state, fasttest::BVDfltNull& parent) {
  983    bool ok = true;
  984    // Value byteVector default optional
  985    if (ok) {
  986        bool prs = lib_fast::GetPmapBit(pmap,1);
  987        if (prs) {
  988            prs = !lib_fast::DecodeNull(from);
  989            if (prs) {
  990                ok = lib_fast::DecodeByteVector(from,parent.Value,true);
  991                if (!ok) {
  992                    state.error << "fasttest.BVDfltNull.Value: bad ByteVector" << eol;
  993                }
  994            }
  995        } else {
  996        }
  997        pmask_qSetBitVal(parent,Value_Present_GetBit(parent),prs);
  998    }
  999    return ok;
 1000}
 1001
 1002// --- fasttest.BVDfltNull..FixEncode
 1003void fasttest::BVDfltNull_FixEncode(cstring& buf, fasttest::BVDfltNull& parent, char soh) {
 1004    if (Value_PresentQ(parent)) {
 1005        buf << "1=" << parent.Value << soh;
 1006    }
 1007}
 1008
 1009// --- fasttest.BVDfltOpt.base.CopyOut
 1010// Copy fields out of row
 1011void fasttest::parent_CopyOut(fasttest::BVDfltOpt &row, fasttest::TemplateHeader &out) {
 1012    // length: field value is computed
 1013    // id: field value is computed
 1014    (void)row;//only to avoid -Wunused-parameter
 1015    (void)out;//only to avoid -Wunused-parameter
 1016}
 1017
 1018// --- fasttest.BVDfltOpt.Value.ReadStrptrMaybe
 1019inline static bool fasttest::Value_ReadStrptrMaybe(fasttest::BVDfltOpt &parent, algo::strptr in_str) {
 1020    bool retval = true;
 1021    algo::Smallstr30 Value_tmp;
 1022    retval = algo::Smallstr30_ReadStrptrMaybe(Value_tmp, in_str);
 1023    if (retval) {
 1024        Value_Set(parent, Value_tmp);
 1025    }
 1026    return retval;
 1027}
 1028
 1029// --- fasttest.BVDfltOpt.pmask_bitcurs.Next
 1030// proceed to next item
 1031void fasttest::BVDfltOpt_pmask_bitcurs_Next(BVDfltOpt_pmask_bitcurs &curs) {
 1032    ++curs.bit;
 1033    int index = curs.bit / 32;
 1034    int offset = curs.bit % 32;
 1035    for (; index < curs.n_elems; ++index, offset = 0) {
 1036        u64 rest = curs.elems[index] >> offset;
 1037        if (rest) {
 1038            offset += algo::u64_BitScanForward(rest);
 1039            break;
 1040        }
 1041    }
 1042    curs.bit = index * 32 + offset;
 1043}
 1044
 1045// --- fasttest.BVDfltOpt..ReadFieldMaybe
 1046bool fasttest::BVDfltOpt_ReadFieldMaybe(fasttest::BVDfltOpt& parent, algo::strptr field, algo::strptr strval) {
 1047    bool retval = true;
 1048    fasttest::FieldId field_id;
 1049    (void)value_SetStrptrMaybe(field_id,field);
 1050    switch(field_id) {
 1051        case fasttest_FieldId_base: {
 1052            retval = false;
 1053            break;
 1054        }
 1055        case fasttest_FieldId_length: {
 1056            retval = false;
 1057            break;
 1058        }
 1059        case fasttest_FieldId_id: {
 1060            retval = false;
 1061            break;
 1062        }
 1063        case fasttest_FieldId_pmask: {
 1064            retval = false;
 1065            break;
 1066        }
 1067        case fasttest_FieldId_Value: {
 1068            retval = Value_ReadStrptrMaybe(parent, strval);
 1069            if (retval) {
 1070                pmask_qSetBit(parent, 0);
 1071            }
 1072            break;
 1073        }
 1074        default: break;
 1075    }
 1076    if (!retval) {
 1077        algo_lib::AppendErrtext("attr",field);
 1078    }
 1079    return retval;
 1080}
 1081
 1082// --- fasttest.BVDfltOpt..ReadStrptrMaybe
 1083// Read fields of fasttest::BVDfltOpt from an ascii string.
 1084// The format of the string is an ssim Tuple
 1085bool fasttest::BVDfltOpt_ReadStrptrMaybe(fasttest::BVDfltOpt &parent, algo::strptr in_str) {
 1086    bool retval = true;
 1087    retval = algo::StripTypeTag(in_str, "fasttest.BVDfltOpt");
 1088    ind_beg(algo::Attr_curs, attr, in_str) {
 1089        retval = retval && BVDfltOpt_ReadFieldMaybe(parent, attr.name, attr.value);
 1090    }ind_end;
 1091    return retval;
 1092}
 1093
 1094// --- fasttest.BVDfltOpt..Print
 1095// print string representation of ROW to string STR
 1096// cfmt:fasttest.BVDfltOpt.String  printfmt:Tuple
 1097void fasttest::BVDfltOpt_Print(fasttest::BVDfltOpt& row, algo::cstring& str) {
 1098    algo::tempstr temp;
 1099    str << "fasttest.BVDfltOpt";
 1100
 1101    if (Value_PresentQ(row)) {
 1102        algo::Smallstr30_Print(row.Value, temp);
 1103        PrintAttrSpaceReset(str,"Value", temp);
 1104    }
 1105}
 1106
 1107// --- fasttest.BVDfltOpt..FastEncode
 1108void fasttest::BVDfltOpt_FastEncode(algo::ByteAry& buf, FastState& state, fasttest::BVDfltOpt& parent) {
 1109    int index = ary_N(buf);
 1110    u64 pmap(0);
 1111    if (!tid_AssignedQ(state) || parent.id != state.tid) {
 1112        lib_fast::EncodeUnsigned(buf,parent.id,false);
 1113        lib_fast::SetPmapBit(pmap,0);
 1114    }
 1115    tid_SetAssigned(state);
 1116    state.tid = parent.id;
 1117    // Value byteVector default optional
 1118    if (Value_PresentQ(parent)) {
 1119        if (parent.Value != "B43") {
 1120            lib_fast::EncodeByteVector(buf,parent.Value,true);
 1121            lib_fast::SetPmapBit(pmap,1);
 1122        }
 1123    } else {
 1124        lib_fast::EncodeNull(buf);
 1125        lib_fast::SetPmapBit(pmap,1);
 1126    }
 1127    lib_fast::InsertPmap(buf,index,pmap);
 1128}
 1129
 1130// --- fasttest.BVDfltOpt..FastDecode
 1131bool fasttest::BVDfltOpt_FastDecode(algo::memptr& from, u64 pmap, FastState& state, fasttest::BVDfltOpt& parent) {
 1132    bool ok = true;
 1133    // Value byteVector default optional
 1134    if (ok) {
 1135        bool prs = lib_fast::GetPmapBit(pmap,1);
 1136        if (prs) {
 1137            prs = !lib_fast::DecodeNull(from);
 1138            if (prs) {
 1139                ok = lib_fast::DecodeByteVector(from,parent.Value,true);
 1140                if (!ok) {
 1141                    state.error << "fasttest.BVDfltOpt.Value: bad ByteVector" << eol;
 1142                }
 1143            }
 1144        } else {
 1145            parent.Value = "B43";
 1146            prs = true;
 1147        }
 1148        pmask_qSetBitVal(parent,Value_Present_GetBit(parent),prs);
 1149    }
 1150    return ok;
 1151}
 1152
 1153// --- fasttest.BVDfltOpt..FixEncode
 1154void fasttest::BVDfltOpt_FixEncode(cstring& buf, fasttest::BVDfltOpt& parent, char soh) {
 1155    if (Value_PresentQ(parent)) {
 1156        buf << "1=" << parent.Value << soh;
 1157    }
 1158}
 1159
 1160// --- fasttest.BVNone.base.CopyOut
 1161// Copy fields out of row
 1162void fasttest::parent_CopyOut(fasttest::BVNone &row, fasttest::TemplateHeader &out) {
 1163    // length: field value is computed
 1164    // id: field value is computed
 1165    (void)row;//only to avoid -Wunused-parameter
 1166    (void)out;//only to avoid -Wunused-parameter
 1167}
 1168
 1169// --- fasttest.BVNone..ReadFieldMaybe
 1170bool fasttest::BVNone_ReadFieldMaybe(fasttest::BVNone& parent, algo::strptr field, algo::strptr strval) {
 1171    bool retval = true;
 1172    fasttest::FieldId field_id;
 1173    (void)value_SetStrptrMaybe(field_id,field);
 1174    switch(field_id) {
 1175        case fasttest_FieldId_base: {
 1176            retval = false;
 1177            break;
 1178        }
 1179        case fasttest_FieldId_length: {
 1180            retval = false;
 1181            break;
 1182        }
 1183        case fasttest_FieldId_id: {
 1184            retval = false;
 1185            break;
 1186        }
 1187        case fasttest_FieldId_Value: {
 1188            retval = algo::Smallstr30_ReadStrptrMaybe(parent.Value, strval);
 1189            break;
 1190        }
 1191        default: break;
 1192    }
 1193    if (!retval) {
 1194        algo_lib::AppendErrtext("attr",field);
 1195    }
 1196    return retval;
 1197}
 1198
 1199// --- fasttest.BVNone..ReadStrptrMaybe
 1200// Read fields of fasttest::BVNone from an ascii string.
 1201// The format of the string is an ssim Tuple
 1202bool fasttest::BVNone_ReadStrptrMaybe(fasttest::BVNone &parent, algo::strptr in_str) {
 1203    bool retval = true;
 1204    retval = algo::StripTypeTag(in_str, "fasttest.BVNone");
 1205    ind_beg(algo::Attr_curs, attr, in_str) {
 1206        retval = retval && BVNone_ReadFieldMaybe(parent, attr.name, attr.value);
 1207    }ind_end;
 1208    return retval;
 1209}
 1210
 1211// --- fasttest.BVNone..Print
 1212// print string representation of ROW to string STR
 1213// cfmt:fasttest.BVNone.String  printfmt:Tuple
 1214void fasttest::BVNone_Print(fasttest::BVNone& row, algo::cstring& str) {
 1215    algo::tempstr temp;
 1216    str << "fasttest.BVNone";
 1217
 1218    algo::Smallstr30_Print(row.Value, temp);
 1219    PrintAttrSpaceReset(str,"Value", temp);
 1220}
 1221
 1222// --- fasttest.BVNone..FastEncode
 1223void fasttest::BVNone_FastEncode(algo::ByteAry& buf, FastState& state, fasttest::BVNone& parent) {
 1224    int index = ary_N(buf);
 1225    u64 pmap(0);
 1226    if (!tid_AssignedQ(state) || parent.id != state.tid) {
 1227        lib_fast::EncodeUnsigned(buf,parent.id,false);
 1228        lib_fast::SetPmapBit(pmap,0);
 1229    }
 1230    tid_SetAssigned(state);
 1231    state.tid = parent.id;
 1232    // Value byteVector none mandatory
 1233    lib_fast::EncodeByteVector(buf,parent.Value,false);
 1234    lib_fast::InsertPmap(buf,index,pmap);
 1235}
 1236
 1237// --- fasttest.BVNone..FastDecode
 1238bool fasttest::BVNone_FastDecode(algo::memptr& from, u64 pmap, FastState& state, fasttest::BVNone& parent) {
 1239    bool ok = true;
 1240    // Value byteVector none mandatory
 1241    if (ok) {
 1242        ok = lib_fast::DecodeByteVector(from,parent.Value,false);
 1243        if (!ok) {
 1244            state.error << "fasttest.BVNone.Value: bad ByteVector" << eol;
 1245        }
 1246    }
 1247    (void)pmap;//only to avoid -Wunused-parameter
 1248    return ok;
 1249}
 1250
 1251// --- fasttest.BVNone..FixEncode
 1252void fasttest::BVNone_FixEncode(cstring& buf, fasttest::BVNone& parent, char soh) {
 1253    buf << "1=" << parent.Value << soh;
 1254}
 1255
 1256// --- fasttest.BVNoneOpt.base.CopyOut
 1257// Copy fields out of row
 1258void fasttest::parent_CopyOut(fasttest::BVNoneOpt &row, fasttest::TemplateHeader &out) {
 1259    // length: field value is computed
 1260    // id: field value is computed
 1261    (void)row;//only to avoid -Wunused-parameter
 1262    (void)out;//only to avoid -Wunused-parameter
 1263}
 1264
 1265// --- fasttest.BVNoneOpt.Value.ReadStrptrMaybe
 1266inline static bool fasttest::Value_ReadStrptrMaybe(fasttest::BVNoneOpt &parent, algo::strptr in_str) {
 1267    bool retval = true;
 1268    algo::Smallstr30 Value_tmp;
 1269    retval = algo::Smallstr30_ReadStrptrMaybe(Value_tmp, in_str);
 1270    if (retval) {
 1271        Value_Set(parent, Value_tmp);
 1272    }
 1273    return retval;
 1274}
 1275
 1276// --- fasttest.BVNoneOpt.pmask_bitcurs.Next
 1277// proceed to next item
 1278void fasttest::BVNoneOpt_pmask_bitcurs_Next(BVNoneOpt_pmask_bitcurs &curs) {
 1279    ++curs.bit;
 1280    int index = curs.bit / 32;
 1281    int offset = curs.bit % 32;
 1282    for (; index < curs.n_elems; ++index, offset = 0) {
 1283        u64 rest = curs.elems[index] >> offset;
 1284        if (rest) {
 1285            offset += algo::u64_BitScanForward(rest);
 1286            break;
 1287        }
 1288    }
 1289    curs.bit = index * 32 + offset;
 1290}
 1291
 1292// --- fasttest.BVNoneOpt..ReadFieldMaybe
 1293bool fasttest::BVNoneOpt_ReadFieldMaybe(fasttest::BVNoneOpt& parent, algo::strptr field, algo::strptr strval) {
 1294    bool retval = true;
 1295    fasttest::FieldId field_id;
 1296    (void)value_SetStrptrMaybe(field_id,field);
 1297    switch(field_id) {
 1298        case fasttest_FieldId_base: {
 1299            retval = false;
 1300            break;
 1301        }
 1302        case fasttest_FieldId_length: {
 1303            retval = false;
 1304            break;
 1305        }
 1306        case fasttest_FieldId_id: {
 1307            retval = false;
 1308            break;
 1309        }
 1310        case fasttest_FieldId_pmask: {
 1311            retval = false;
 1312            break;
 1313        }
 1314        case fasttest_FieldId_Value: {
 1315            retval = Value_ReadStrptrMaybe(parent, strval);
 1316            if (retval) {
 1317                pmask_qSetBit(parent, 0);
 1318            }
 1319            break;
 1320        }
 1321        default: break;
 1322    }
 1323    if (!retval) {
 1324        algo_lib::AppendErrtext("attr",field);
 1325    }
 1326    return retval;
 1327}
 1328
 1329// --- fasttest.BVNoneOpt..ReadStrptrMaybe
 1330// Read fields of fasttest::BVNoneOpt from an ascii string.
 1331// The format of the string is an ssim Tuple
 1332bool fasttest::BVNoneOpt_ReadStrptrMaybe(fasttest::BVNoneOpt &parent, algo::strptr in_str) {
 1333    bool retval = true;
 1334    retval = algo::StripTypeTag(in_str, "fasttest.BVNoneOpt");
 1335    ind_beg(algo::Attr_curs, attr, in_str) {
 1336        retval = retval && BVNoneOpt_ReadFieldMaybe(parent, attr.name, attr.value);
 1337    }ind_end;
 1338    return retval;
 1339}
 1340
 1341// --- fasttest.BVNoneOpt..Print
 1342// print string representation of ROW to string STR
 1343// cfmt:fasttest.BVNoneOpt.String  printfmt:Tuple
 1344void fasttest::BVNoneOpt_Print(fasttest::BVNoneOpt& row, algo::cstring& str) {
 1345    algo::tempstr temp;
 1346    str << "fasttest.BVNoneOpt";
 1347
 1348    if (Value_PresentQ(row)) {
 1349        algo::Smallstr30_Print(row.Value, temp);
 1350        PrintAttrSpaceReset(str,"Value", temp);
 1351    }
 1352}
 1353
 1354// --- fasttest.BVNoneOpt..FastEncode
 1355void fasttest::BVNoneOpt_FastEncode(algo::ByteAry& buf, FastState& state, fasttest::BVNoneOpt& parent) {
 1356    int index = ary_N(buf);
 1357    u64 pmap(0);
 1358    if (!tid_AssignedQ(state) || parent.id != state.tid) {
 1359        lib_fast::EncodeUnsigned(buf,parent.id,false);
 1360        lib_fast::SetPmapBit(pmap,0);
 1361    }
 1362    tid_SetAssigned(state);
 1363    state.tid = parent.id;
 1364    // Value byteVector none optional
 1365    if (Value_PresentQ(parent)) {
 1366        lib_fast::EncodeByteVector(buf,parent.Value,true);
 1367    } else {
 1368        lib_fast::EncodeNull(buf);
 1369    }
 1370    lib_fast::InsertPmap(buf,index,pmap);
 1371}
 1372
 1373// --- fasttest.BVNoneOpt..FastDecode
 1374bool fasttest::BVNoneOpt_FastDecode(algo::memptr& from, u64 pmap, FastState& state, fasttest::BVNoneOpt& parent) {
 1375    bool ok = true;
 1376    // Value byteVector none optional
 1377    if (ok) {
 1378        bool prs = !lib_fast::DecodeNull(from);
 1379        if (prs) {
 1380            ok = lib_fast::DecodeByteVector(from,parent.Value,true);
 1381            if (!ok) {
 1382                state.error << "fasttest.BVNoneOpt.Value: bad ByteVector" << eol;
 1383            }
 1384        }
 1385        pmask_qSetBitVal(parent,Value_Present_GetBit(parent),prs);
 1386    }
 1387    (void)pmap;//only to avoid -Wunused-parameter
 1388    return ok;
 1389}
 1390
 1391// --- fasttest.BVNoneOpt..FixEncode
 1392void fasttest::BVNoneOpt_FixEncode(cstring& buf, fasttest::BVNoneOpt& parent, char soh) {
 1393    if (Value_PresentQ(parent)) {
 1394        buf << "1=" << parent.Value << soh;
 1395    }
 1396}
 1397
 1398// --- fasttest.SampleEnum.value.ToCstr
 1399// Convert numeric value of field to one of predefined string constants.
 1400// If string is found, return a static C string. Otherwise, return NULL.
 1401const char* fasttest::value_ToCstr(const fasttest::SampleEnum& parent) {
 1402    const char *ret = NULL;
 1403    switch(value_GetEnum(parent)) {
 1404        case fasttest_SampleEnum_first     : ret = "first";  break;
 1405        case fasttest_SampleEnum_second    : ret = "second";  break;
 1406        case fasttest_SampleEnum_third     : ret = "third";  break;
 1407    }
 1408    return ret;
 1409}
 1410
 1411// --- fasttest.SampleEnum.value.Print
 1412// Convert value to a string. First, attempt conversion to a known string.
 1413// If no string matches, print value as a numeric value.
 1414void fasttest::value_Print(const fasttest::SampleEnum& parent, algo::cstring &lhs) {
 1415    const char *strval = value_ToCstr(parent);
 1416    if (strval) {
 1417        lhs << strval;
 1418    } else {
 1419        lhs << parent.value;
 1420    }
 1421}
 1422
 1423// --- fasttest.SampleEnum.value.SetStrptrMaybe
 1424// Convert string to field.
 1425// If the string is invalid, do not modify field and return false.
 1426// In case of success, return true
 1427bool fasttest::value_SetStrptrMaybe(fasttest::SampleEnum& parent, algo::strptr rhs) {
 1428    bool ret = false;
 1429    switch (elems_N(rhs)) {
 1430        case 5: {
 1431            switch (u64(algo::ReadLE32(rhs.elems))|(u64(rhs[4])<<32)) {
 1432                case LE_STR5('f','i','r','s','t'): {
 1433                    value_SetEnum(parent,fasttest_SampleEnum_first); ret = true; break;
 1434                }
 1435                case LE_STR5('t','h','i','r','d'): {
 1436                    value_SetEnum(parent,fasttest_SampleEnum_third); ret = true; break;
 1437                }
 1438            }
 1439            break;
 1440        }
 1441        case 6: {
 1442            switch (u64(algo::ReadLE32(rhs.elems))|(u64(algo::ReadLE16(rhs.elems+4))<<32)) {
 1443                case LE_STR6('s','e','c','o','n','d'): {
 1444                    value_SetEnum(parent,fasttest_SampleEnum_second); ret = true; break;
 1445                }
 1446            }
 1447            break;
 1448        }
 1449    }
 1450    return ret;
 1451}
 1452
 1453// --- fasttest.SampleEnum.value.SetStrptr
 1454// Convert string to field.
 1455// If the string is invalid, set numeric value to DFLT
 1456void fasttest::value_SetStrptr(fasttest::SampleEnum& parent, algo::strptr rhs, fasttest_SampleEnumEnum dflt) {
 1457    if (!value_SetStrptrMaybe(parent,rhs)) value_SetEnum(parent,dflt);
 1458}
 1459
 1460// --- fasttest.SampleEnum.value.ReadStrptrMaybe
 1461// Convert string to field. Return success value
 1462bool fasttest::value_ReadStrptrMaybe(fasttest::SampleEnum& parent, algo::strptr rhs) {
 1463    bool retval = false;
 1464    retval = value_SetStrptrMaybe(parent,rhs); // try symbol conversion
 1465    if (!retval) { // didn't work? try reading as underlying type
 1466        retval = u32_ReadStrptrMaybe(parent.value,rhs);
 1467    }
 1468    return retval;
 1469}
 1470
 1471// --- fasttest.SampleEnum..ReadStrptrMaybe
 1472// Read fields of fasttest::SampleEnum from an ascii string.
 1473// The format of the string is the format of the fasttest::SampleEnum's only field
 1474bool fasttest::SampleEnum_ReadStrptrMaybe(fasttest::SampleEnum &parent, algo::strptr in_str) {
 1475    bool retval = true;
 1476    retval = retval && value_ReadStrptrMaybe(parent, in_str);
 1477    return retval;
 1478}
 1479
 1480// --- fasttest.SampleEnum..Print
 1481// print string representation of ROW to string STR
 1482// cfmt:fasttest.SampleEnum.String  printfmt:Raw
 1483void fasttest::SampleEnum_Print(fasttest::SampleEnum row, algo::cstring& str) {
 1484    fasttest::value_Print(row, str);
 1485}
 1486
 1487// --- fasttest.SampleSet.prima.ReadStrptrMaybe
 1488inline static bool fasttest::prima_ReadStrptrMaybe(fasttest::SampleSet &parent, algo::strptr in_str) {
 1489    bool retval = true;
 1490    bool prima_tmp;
 1491    retval = bool_ReadStrptrMaybe(prima_tmp, in_str);
 1492    if (retval) {
 1493        prima_Set(parent, prima_tmp);
 1494    }
 1495    return retval;
 1496}
 1497
 1498// --- fasttest.SampleSet.secunda.ReadStrptrMaybe
 1499inline static bool fasttest::secunda_ReadStrptrMaybe(fasttest::SampleSet &parent, algo::strptr in_str) {
 1500    bool retval = true;
 1501    bool secunda_tmp;
 1502    retval = bool_ReadStrptrMaybe(secunda_tmp, in_str);
 1503    if (retval) {
 1504        secunda_Set(parent, secunda_tmp);
 1505    }
 1506    return retval;
 1507}
 1508
 1509// --- fasttest.SampleSet.tertia.ReadStrptrMaybe
 1510inline static bool fasttest::tertia_ReadStrptrMaybe(fasttest::SampleSet &parent, algo::strptr in_str) {
 1511    bool retval = true;
 1512    bool tertia_tmp;
 1513    retval = bool_ReadStrptrMaybe(tertia_tmp, in_str);
 1514    if (retval) {
 1515        tertia_Set(parent, tertia_tmp);
 1516    }
 1517    return retval;
 1518}
 1519
 1520// --- fasttest.SampleSet..ReadFieldMaybe
 1521bool fasttest::SampleSet_ReadFieldMaybe(fasttest::SampleSet& parent, algo::strptr field, algo::strptr strval) {
 1522    bool retval = true;
 1523    fasttest::FieldId field_id;
 1524    (void)value_SetStrptrMaybe(field_id,field);
 1525    switch(field_id) {
 1526        case fasttest_FieldId_value: {
 1527            retval = u32_ReadStrptrMaybe(parent.value, strval);
 1528            break;
 1529        }
 1530        case fasttest_FieldId_prima: {
 1531            retval = prima_ReadStrptrMaybe(parent, strval);
 1532            break;
 1533        }
 1534        case fasttest_FieldId_secunda: {
 1535            retval = secunda_ReadStrptrMaybe(parent, strval);
 1536            break;
 1537        }
 1538        case fasttest_FieldId_tertia: {
 1539            retval = tertia_ReadStrptrMaybe(parent, strval);
 1540            break;
 1541        }
 1542        default: break;
 1543    }
 1544    if (!retval) {
 1545        algo_lib::AppendErrtext("attr",field);
 1546    }
 1547    return retval;
 1548}
 1549
 1550// --- fasttest.SampleSet..ReadStrptrMaybe
 1551// Read fields of fasttest::SampleSet from an ascii string.
 1552bool fasttest::SampleSet_ReadStrptrMaybe(fasttest::SampleSet &parent, algo::strptr in_str) {
 1553    bool retval = true;
 1554    // Clear affected bits first)
 1555    prima_Set(parent, false);
 1556    secunda_Set(parent, false);
 1557    tertia_Set(parent, false);
 1558    // Read ' '-separated list of bools
 1559    while (ch_N(in_str)) {
 1560        strptr field_name;
 1561        algo::NextSep(in_str,' ',field_name);
 1562        field_name = algo::Trimmed(field_name);
 1563        if (ch_N(field_name)) {
 1564            fasttest::FieldId field_id;
 1565            bool ok = fasttest::value_SetStrptrMaybe(field_id,field_name);
 1566            if (ok) {
 1567                switch (field_id) {
 1568                    case fasttest_FieldId_prima: {
 1569                        prima_Set(parent, true);
 1570                    } break;
 1571                    case fasttest_FieldId_secunda: {
 1572                        secunda_Set(parent, true);
 1573                    } break;
 1574                    case fasttest_FieldId_tertia: {
 1575                        tertia_Set(parent, true);
 1576                    } break;
 1577                    default: ok = false; break;
 1578                }
 1579            }
 1580            if (!ok) {
 1581                algo_lib::AppendErrtext("bitfld",field_name);
 1582                retval = false;
 1583            }
 1584        }
 1585    }
 1586    return retval;
 1587}
 1588
 1589// --- fasttest.SampleSet..Print
 1590// print string representation of ROW to string STR
 1591// cfmt:fasttest.SampleSet.String  printfmt:Bitset
 1592void fasttest::SampleSet_Print(fasttest::SampleSet row, algo::cstring& str) {
 1593    algo::ListSep ls(" ");
 1594    if (prima_Get(row)) {
 1595        str << ls << "prima";
 1596    }
 1597    if (secunda_Get(row)) {
 1598        str << ls << "secunda";
 1599    }
 1600    if (tertia_Get(row)) {
 1601        str << ls << "tertia";
 1602    }
 1603}
 1604
 1605// --- fasttest.FastState.assigned_bitcurs.Next
 1606// proceed to next item
 1607void fasttest::FastState_assigned_bitcurs_Next(FastState_assigned_bitcurs &curs) {
 1608    ++curs.bit;
 1609    int index = curs.bit / 64;
 1610    int offset = curs.bit % 64;
 1611    for (; index < curs.n_elems; ++index, offset = 0) {
 1612        u64 rest = curs.elems[index] >> offset;
 1613        if (rest) {
 1614            offset += algo::u64_BitScanForward(rest);
 1615            break;
 1616        }
 1617    }
 1618    curs.bit = index * 64 + offset;
 1619}
 1620
 1621// --- fasttest.FastState.present_bitcurs.Next
 1622// proceed to next item
 1623void fasttest::FastState_present_bitcurs_Next(FastState_present_bitcurs &curs) {
 1624    ++curs.bit;
 1625    int index = curs.bit / 32;
 1626    int offset = curs.bit % 32;
 1627    for (; index < curs.n_elems; ++index, offset = 0) {
 1628        u64 rest = curs.elems[index] >> offset;
 1629        if (rest) {
 1630            offset += algo::u64_BitScanForward(rest);
 1631            break;
 1632        }
 1633    }
 1634    curs.bit = index * 32 + offset;
 1635}
 1636
 1637// --- fasttest.FastState..Init
 1638// Set all fields to initial values.
 1639void fasttest::FastState_Init(fasttest::FastState& parent) {
 1640    parent.assigned = u64(0);
 1641    parent.present = u32(0);
 1642    parent.tid = u32(0);
 1643    parent.Value49 = i32(0);
 1644    parent.Value50 = i32(0);
 1645    parent.Value51 = i32(0);
 1646    parent.Value52 = u32(0);
 1647    parent.Value53 = u32(0);
 1648    parent.Value54 = u32(0);
 1649    parent.Value65 = i32(0);
 1650    parent.Value66 = i32(0);
 1651    parent.Value67 = i32(0);
 1652    parent.Value68 = i32(0);
 1653    parent.Value69 = u32(0);
 1654    parent.Value70 = u32(0);
 1655    parent.Value71 = u32(0);
 1656    parent.Value72 = u32(0);
 1657    parent.Value97 = i32(0);
 1658    parent.Value98 = i32(0);
 1659    parent.Value99 = i32(0);
 1660    parent.Value100 = i32(0);
 1661    parent.Value101 = u32(0);
 1662    parent.Value102 = u32(0);
 1663    parent.Value103 = u32(0);
 1664    parent.Value104 = u32(0);
 1665}
 1666
 1667// --- fasttest.FieldId.value.ToCstr
 1668// Convert numeric value of field to one of predefined string constants.
 1669// If string is found, return a static C string. Otherwise, return NULL.
 1670const char* fasttest::value_ToCstr(const fasttest::FieldId& parent) {
 1671    const char *ret = NULL;
 1672    switch(value_GetEnum(parent)) {
 1673        case fasttest_FieldId_base         : ret = "base";  break;
 1674        case fasttest_FieldId_length       : ret = "length";  break;
 1675        case fasttest_FieldId_id           : ret = "id";  break;
 1676        case fasttest_FieldId_Value        : ret = "Value";  break;
 1677        case fasttest_FieldId_pmask        : ret = "pmask";  break;
 1678        case fasttest_FieldId_Value58      : ret = "Value58";  break;
 1679        case fasttest_FieldId_Value60      : ret = "Value60";  break;
 1680        case fasttest_FieldId_Value59      : ret = "Value59";  break;
 1681        case fasttest_FieldId_Value1       : ret = "Value1";  break;
 1682        case fasttest_FieldId_OptSgmGrp    : ret = "OptSgmGrp";  break;
 1683        case fasttest_FieldId_TrvGrp       : ret = "TrvGrp";  break;
 1684        case fasttest_FieldId_OptTrvGrp    : ret = "OptTrvGrp";  break;
 1685        case fasttest_FieldId_Value49      : ret = "Value49";  break;
 1686        case fasttest_FieldId_Value51      : ret = "Value51";  break;
 1687        case fasttest_FieldId_Value50      : ret = "Value50";  break;
 1688        case fasttest_FieldId_Value65      : ret = "Value65";  break;
 1689        case fasttest_FieldId_Value66      : ret = "Value66";  break;
 1690        case fasttest_FieldId_Value68      : ret = "Value68";  break;
 1691        case fasttest_FieldId_Value67      : ret = "Value67";  break;
 1692        case fasttest_FieldId_Value97      : ret = "Value97";  break;
 1693        case fasttest_FieldId_Value98      : ret = "Value98";  break;
 1694        case fasttest_FieldId_Value100     : ret = "Value100";  break;
 1695        case fasttest_FieldId_Value99      : ret = "Value99";  break;
 1696        case fasttest_FieldId_Value2       : ret = "Value2";  break;
 1697        case fasttest_FieldId_Value3       : ret = "Value3";  break;
 1698        case fasttest_FieldId_Value4       : ret = "Value4";  break;
 1699        case fasttest_FieldId_Value5       : ret = "Value5";  break;
 1700        case fasttest_FieldId_Value6       : ret = "Value6";  break;
 1701        case fasttest_FieldId_Value7       : ret = "Value7";  break;
 1702        case fasttest_FieldId_Value8       : ret = "Value8";  break;
 1703        case fasttest_FieldId_Value9       : ret = "Value9";  break;
 1704        case fasttest_FieldId_Value10      : ret = "Value10";  break;
 1705        case fasttest_FieldId_Value11      : ret = "Value11";  break;
 1706        case fasttest_FieldId_Value12      : ret = "Value12";  break;
 1707        case fasttest_FieldId_Value13      : ret = "Value13";  break;
 1708        case fasttest_FieldId_Value14      : ret = "Value14";  break;
 1709        case fasttest_FieldId_Value15      : ret = "Value15";  break;
 1710        case fasttest_FieldId_Value16      : ret = "Value16";  break;
 1711        case fasttest_FieldId_Value17      : ret = "Value17";  break;
 1712        case fasttest_FieldId_Value18      : ret = "Value18";  break;
 1713        case fasttest_FieldId_Value19      : ret = "Value19";  break;
 1714        case fasttest_FieldId_Value20      : ret = "Value20";  break;
 1715        case fasttest_FieldId_Value21      : ret = "Value21";  break;
 1716        case fasttest_FieldId_Value22      : ret = "Value22";  break;
 1717        case fasttest_FieldId_Value23      : ret = "Value23";  break;
 1718        case fasttest_FieldId_Value24      : ret = "Value24";  break;
 1719        case fasttest_FieldId_Value25      : ret = "Value25";  break;
 1720        case fasttest_FieldId_Value26      : ret = "Value26";  break;
 1721        case fasttest_FieldId_Value27      : ret = "Value27";  break;
 1722        case fasttest_FieldId_Value28      : ret = "Value28";  break;
 1723        case fasttest_FieldId_Value29      : ret = "Value29";  break;
 1724        case fasttest_FieldId_Value30      : ret = "Value30";  break;
 1725        case fasttest_FieldId_Value31      : ret = "Value31";  break;
 1726        case fasttest_FieldId_Value32      : ret = "Value32";  break;
 1727        case fasttest_FieldId_Value33      : ret = "Value33";  break;
 1728        case fasttest_FieldId_Value34      : ret = "Value34";  break;
 1729        case fasttest_FieldId_Value35      : ret = "Value35";  break;
 1730        case fasttest_FieldId_Value36      : ret = "Value36";  break;
 1731        case fasttest_FieldId_Value37      : ret = "Value37";  break;
 1732        case fasttest_FieldId_Value38      : ret = "Value38";  break;
 1733        case fasttest_FieldId_Value39      : ret = "Value39";  break;
 1734        case fasttest_FieldId_Value40      : ret = "Value40";  break;
 1735        case fasttest_FieldId_Value41      : ret = "Value41";  break;
 1736        case fasttest_FieldId_Value42      : ret = "Value42";  break;
 1737        case fasttest_FieldId_Value43      : ret = "Value43";  break;
 1738        case fasttest_FieldId_Value44      : ret = "Value44";  break;
 1739        case fasttest_FieldId_Value45      : ret = "Value45";  break;
 1740        case fasttest_FieldId_Value46      : ret = "Value46";  break;
 1741        case fasttest_FieldId_Value47      : ret = "Value47";  break;
 1742        case fasttest_FieldId_Value48      : ret = "Value48";  break;
 1743        case fasttest_FieldId_Value52      : ret = "Value52";  break;
 1744        case fasttest_FieldId_Value53      : ret = "Value53";  break;
 1745        case fasttest_FieldId_Value54      : ret = "Value54";  break;
 1746        case fasttest_FieldId_Value55      : ret = "Value55";  break;
 1747        case fasttest_FieldId_Value56      : ret = "Value56";  break;
 1748        case fasttest_FieldId_Value57      : ret = "Value57";  break;
 1749        case fasttest_FieldId_Value61      : ret = "Value61";  break;
 1750        case fasttest_FieldId_Value62      : ret = "Value62";  break;
 1751        case fasttest_FieldId_Value63      : ret = "Value63";  break;
 1752        case fasttest_FieldId_value        : ret = "value";  break;
 1753        case fasttest_FieldId_Value147     : ret = "Value147";  break;
 1754        case fasttest_FieldId_prima        : ret = "prima";  break;
 1755        case fasttest_FieldId_secunda      : ret = "secunda";  break;
 1756        case fasttest_FieldId_tertia       : ret = "tertia";  break;
 1757        case fasttest_FieldId_Value150     : ret = "Value150";  break;
 1758        case fasttest_FieldId_Value81      : ret = "Value81";  break;
 1759        case fasttest_FieldId_Value82      : ret = "Value82";  break;
 1760        case fasttest_FieldId_Value84      : ret = "Value84";  break;
 1761        case fasttest_FieldId_Value83      : ret = "Value83";  break;
 1762        case fasttest_FieldId_SecondSeq    : ret = "SecondSeq";  break;
 1763        case fasttest_FieldId_FirstSeq     : ret = "FirstSeq";  break;
 1764        case fasttest_FieldId_OptSgmSeq    : ret = "OptSgmSeq";  break;
 1765        case fasttest_FieldId_TrvSeq       : ret = "TrvSeq";  break;
 1766        case fasttest_FieldId_TrvSeqLenConst: ret = "TrvSeqLenConst";  break;
 1767        case fasttest_FieldId_TrvSeqLenConstOpt: ret = "TrvSeqLenConstOpt";  break;
 1768        case fasttest_FieldId_TrvSeqLenDflt: ret = "TrvSeqLenDflt";  break;
 1769        case fasttest_FieldId_TrvSeqDfltOpt: ret = "TrvSeqDfltOpt";  break;
 1770        case fasttest_FieldId_TrvSeqLenNone: ret = "TrvSeqLenNone";  break;
 1771        case fasttest_FieldId_TrvSeqLenNoneOpt: ret = "TrvSeqLenNoneOpt";  break;
 1772        case fasttest_FieldId_OptTrvSeq    : ret = "OptTrvSeq";  break;
 1773        case fasttest_FieldId_Value69      : ret = "Value69";  break;
 1774        case fasttest_FieldId_Value70      : ret = "Value70";  break;
 1775        case fasttest_FieldId_Value72      : ret = "Value72";  break;
 1776        case fasttest_FieldId_Value71      : ret = "Value71";  break;
 1777        case fasttest_FieldId_Value101     : ret = "Value101";  break;
 1778        case fasttest_FieldId_Value102     : ret = "Value102";  break;
 1779        case fasttest_FieldId_Value104     : ret = "Value104";  break;
 1780        case fasttest_FieldId_Value103     : ret = "Value103";  break;
 1781    }
 1782    return ret;
 1783}
 1784
 1785// --- fasttest.FieldId.value.Print
 1786// Convert value to a string. First, attempt conversion to a known string.
 1787// If no string matches, print value as a numeric value.
 1788void fasttest::value_Print(const fasttest::FieldId& parent, algo::cstring &lhs) {
 1789    const char *strval = value_ToCstr(parent);
 1790    if (strval) {
 1791        lhs << strval;
 1792    } else {
 1793        lhs << parent.value;
 1794    }
 1795}
 1796
 1797// --- fasttest.FieldId.value.SetStrptrMaybe
 1798// Convert string to field.
 1799// If the string is invalid, do not modify field and return false.
 1800// In case of success, return true
 1801bool fasttest::value_SetStrptrMaybe(fasttest::FieldId& parent, algo::strptr rhs) {
 1802    bool ret = false;
 1803    switch (elems_N(rhs)) {
 1804        case 2: {
 1805            switch (u64(algo::ReadLE16(rhs.elems))) {
 1806                case LE_STR2('i','d'): {
 1807                    value_SetEnum(parent,fasttest_FieldId_id); ret = true; break;
 1808                }
 1809            }
 1810            break;
 1811        }
 1812        case 4: {
 1813            switch (u64(algo::ReadLE32(rhs.elems))) {
 1814                case LE_STR4('b','a','s','e'): {
 1815                    value_SetEnum(parent,fasttest_FieldId_base); ret = true; break;
 1816                }
 1817            }
 1818            break;
 1819        }
 1820        case 5: {
 1821            switch (u64(algo::ReadLE32(rhs.elems))|(u64(rhs[4])<<32)) {
 1822                case LE_STR5('V','a','l','u','e'): {
 1823                    value_SetEnum(parent,fasttest_FieldId_Value); ret = true; break;
 1824                }
 1825                case LE_STR5('p','m','a','s','k'): {
 1826                    value_SetEnum(parent,fasttest_FieldId_pmask); ret = true; break;
 1827                }
 1828                case LE_STR5('p','r','i','m','a'): {
 1829                    value_SetEnum(parent,fasttest_FieldId_prima); ret = true; break;
 1830                }
 1831                case LE_STR5('v','a','l','u','e'): {
 1832                    value_SetEnum(parent,fasttest_FieldId_value); ret = true; break;
 1833                }
 1834            }
 1835            break;
 1836        }
 1837        case 6: {
 1838            switch (u64(algo::ReadLE32(rhs.elems))|(u64(algo::ReadLE16(rhs.elems+4))<<32)) {
 1839                case LE_STR6('T','r','v','G','r','p'): {
 1840                    value_SetEnum(parent,fasttest_FieldId_TrvGrp); ret = true; break;
 1841                }
 1842                case LE_STR6('T','r','v','S','e','q'): {
 1843                    value_SetEnum(parent,fasttest_FieldId_TrvSeq); ret = true; break;
 1844                }
 1845                case LE_STR6('V','a','l','u','e','1'): {
 1846                    value_SetEnum(parent,fasttest_FieldId_Value1); ret = true; break;
 1847                }
 1848                case LE_STR6('V','a','l','u','e','2'): {
 1849                    value_SetEnum(parent,fasttest_FieldId_Value2); ret = true; break;
 1850                }
 1851                case LE_STR6('V','a','l','u','e','3'): {
 1852                    value_SetEnum(parent,fasttest_FieldId_Value3); ret = true; break;
 1853                }
 1854                case LE_STR6('V','a','l','u','e','4'): {
 1855                    value_SetEnum(parent,fasttest_FieldId_Value4); ret = true; break;
 1856                }
 1857                case LE_STR6('V','a','l','u','e','5'): {
 1858                    value_SetEnum(parent,fasttest_FieldId_Value5); ret = true; break;
 1859                }
 1860                case LE_STR6('V','a','l','u','e','6'): {
 1861                    value_SetEnum(parent,fasttest_FieldId_Value6); ret = true; break;
 1862                }
 1863                case LE_STR6('V','a','l','u','e','7'): {
 1864                    value_SetEnum(parent,fasttest_FieldId_Value7); ret = true; break;
 1865                }
 1866                case LE_STR6('V','a','l','u','e','8'): {
 1867                    value_SetEnum(parent,fasttest_FieldId_Value8); ret = true; break;
 1868                }
 1869                case LE_STR6('V','a','l','u','e','9'): {
 1870                    value_SetEnum(parent,fasttest_FieldId_Value9); ret = true; break;
 1871                }
 1872                case LE_STR6('l','e','n','g','t','h'): {
 1873                    value_SetEnum(parent,fasttest_FieldId_length); ret = true; break;
 1874                }
 1875                case LE_STR6('t','e','r','t','i','a'): {
 1876                    value_SetEnum(parent,fasttest_FieldId_tertia); ret = true; break;
 1877                }
 1878            }
 1879            break;
 1880        }
 1881        case 7: {
 1882            switch (u64(algo::ReadLE32(rhs.elems))|(u64(algo::ReadLE16(rhs.elems+4))<<32)|(u64(rhs[6])<<48)) {
 1883                case LE_STR7('V','a','l','u','e','1','0'): {
 1884                    value_SetEnum(parent,fasttest_FieldId_Value10); ret = true; break;
 1885                }
 1886                case LE_STR7('V','a','l','u','e','1','1'): {
 1887                    value_SetEnum(parent,fasttest_FieldId_Value11); ret = true; break;
 1888                }
 1889                case LE_STR7('V','a','l','u','e','1','2'): {
 1890                    value_SetEnum(parent,fasttest_FieldId_Value12); ret = true; break;
 1891                }
 1892                case LE_STR7('V','a','l','u','e','1','3'): {
 1893                    value_SetEnum(parent,fasttest_FieldId_Value13); ret = true; break;
 1894                }
 1895                case LE_STR7('V','a','l','u','e','1','4'): {
 1896                    value_SetEnum(parent,fasttest_FieldId_Value14); ret = true; break;
 1897                }
 1898                case LE_STR7('V','a','l','u','e','1','5'): {
 1899                    value_SetEnum(parent,fasttest_FieldId_Value15); ret = true; break;
 1900                }
 1901                case LE_STR7('V','a','l','u','e','1','6'): {
 1902                    value_SetEnum(parent,fasttest_FieldId_Value16); ret = true; break;
 1903                }
 1904                case LE_STR7('V','a','l','u','e','1','7'): {
 1905                    value_SetEnum(parent,fasttest_FieldId_Value17); ret = true; break;
 1906                }
 1907                case LE_STR7('V','a','l','u','e','1','8'): {
 1908                    value_SetEnum(parent,fasttest_FieldId_Value18); ret = true; break;
 1909                }
 1910                case LE_STR7('V','a','l','u','e','1','9'): {
 1911                    value_SetEnum(parent,fasttest_FieldId_Value19); ret = true; break;
 1912                }
 1913                case LE_STR7('V','a','l','u','e','2','0'): {
 1914                    value_SetEnum(parent,fasttest_FieldId_Value20); ret = true; break;
 1915                }
 1916                case LE_STR7('V','a','l','u','e','2','1'): {
 1917                    value_SetEnum(parent,fasttest_FieldId_Value21); ret = true; break;
 1918                }
 1919                case LE_STR7('V','a','l','u','e','2','2'): {
 1920                    value_SetEnum(parent,fasttest_FieldId_Value22); ret = true; break;
 1921                }
 1922                case LE_STR7('V','a','l','u','e','2','3'): {
 1923                    value_SetEnum(parent,fasttest_FieldId_Value23); ret = true; break;
 1924                }
 1925                case LE_STR7('V','a','l','u','e','2','4'): {
 1926                    value_SetEnum(parent,fasttest_FieldId_Value24); ret = true; break;
 1927                }
 1928                case LE_STR7('V','a','l','u','e','2','5'): {
 1929                    value_SetEnum(parent,fasttest_FieldId_Value25); ret = true; break;
 1930                }
 1931                case LE_STR7('V','a','l','u','e','2','6'): {
 1932                    value_SetEnum(parent,fasttest_FieldId_Value26); ret = true; break;
 1933                }
 1934                case LE_STR7('V','a','l','u','e','2','7'): {
 1935                    value_SetEnum(parent,fasttest_FieldId_Value27); ret = true; break;
 1936                }
 1937                case LE_STR7('V','a','l','u','e','2','8'): {
 1938                    value_SetEnum(parent,fasttest_FieldId_Value28); ret = true; break;
 1939                }
 1940                case LE_STR7('V','a','l','u','e','2','9'): {
 1941                    value_SetEnum(parent,fasttest_FieldId_Value29); ret = true; break;
 1942                }
 1943                case LE_STR7('V','a','l','u','e','3','0'): {
 1944                    value_SetEnum(parent,fasttest_FieldId_Value30); ret = true; break;
 1945                }
 1946                case LE_STR7('V','a','l','u','e','3','1'): {
 1947                    value_SetEnum(parent,fasttest_FieldId_Value31); ret = true; break;
 1948                }
 1949                case LE_STR7('V','a','l','u','e','3','2'): {
 1950                    value_SetEnum(parent,fasttest_FieldId_Value32); ret = true; break;
 1951                }
 1952                case LE_STR7('V','a','l','u','e','3','3'): {
 1953                    value_SetEnum(parent,fasttest_FieldId_Value33); ret = true; break;
 1954                }
 1955                case LE_STR7('V','a','l','u','e','3','4'): {
 1956                    value_SetEnum(parent,fasttest_FieldId_Value34); ret = true; break;
 1957                }
 1958                case LE_STR7('V','a','l','u','e','3','5'): {
 1959                    value_SetEnum(parent,fasttest_FieldId_Value35); ret = true; break;
 1960                }
 1961                case LE_STR7('V','a','l','u','e','3','6'): {
 1962                    value_SetEnum(parent,fasttest_FieldId_Value36); ret = true; break;
 1963                }
 1964                case LE_STR7('V','a','l','u','e','3','7'): {
 1965                    value_SetEnum(parent,fasttest_FieldId_Value37); ret = true; break;
 1966                }
 1967                case LE_STR7('V','a','l','u','e','3','8'): {
 1968                    value_SetEnum(parent,fasttest_FieldId_Value38); ret = true; break;
 1969                }
 1970                case LE_STR7('V','a','l','u','e','3','9'): {
 1971                    value_SetEnum(parent,fasttest_FieldId_Value39); ret = true; break;
 1972                }
 1973                case LE_STR7('V','a','l','u','e','4','0'): {
 1974                    value_SetEnum(parent,fasttest_FieldId_Value40); ret = true; break;
 1975                }
 1976                case LE_STR7('V','a','l','u','e','4','1'): {
 1977                    value_SetEnum(parent,fasttest_FieldId_Value41); ret = true; break;
 1978                }
 1979                case LE_STR7('V','a','l','u','e','4','2'): {
 1980                    value_SetEnum(parent,fasttest_FieldId_Value42); ret = true; break;
 1981                }
 1982                case LE_STR7('V','a','l','u','e','4','3'): {
 1983                    value_SetEnum(parent,fasttest_FieldId_Value43); ret = true; break;
 1984                }
 1985                case LE_STR7('V','a','l','u','e','4','4'): {
 1986                    value_SetEnum(parent,fasttest_FieldId_Value44); ret = true; break;
 1987                }
 1988                case LE_STR7('V','a','l','u','e','4','5'): {
 1989                    value_SetEnum(parent,fasttest_FieldId_Value45); ret = true; break;
 1990                }
 1991                case LE_STR7('V','a','l','u','e','4','6'): {
 1992                    value_SetEnum(parent,fasttest_FieldId_Value46); ret = true; break;
 1993                }
 1994                case LE_STR7('V','a','l','u','e','4','7'): {
 1995                    value_SetEnum(parent,fasttest_FieldId_Value47); ret = true; break;
 1996                }
 1997                case LE_STR7('V','a','l','u','e','4','8'): {
 1998                    value_SetEnum(parent,fasttest_FieldId_Value48); ret = true; break;
 1999                }
 2000                case LE_STR7('V','a','l','u','e','4','9'): {
 2001                    value_SetEnum(parent,fasttest_FieldId_Value49); ret = true; break;
 2002                }
 2003                case LE_STR7('V','a','l','u','e','5','0'): {
 2004                    value_SetEnum(parent,fasttest_FieldId_Value50); ret = true; break;
 2005                }
 2006                case LE_STR7('V','a','l','u','e','5','1'): {
 2007                    value_SetEnum(parent,fasttest_FieldId_Value51); ret = true; break;
 2008                }
 2009                case LE_STR7('V','a','l','u','e','5','2'): {
 2010                    value_SetEnum(parent,fasttest_FieldId_Value52); ret = true; break;
 2011                }
 2012                case LE_STR7('V','a','l','u','e','5','3'): {
 2013                    value_SetEnum(parent,fasttest_FieldId_Value53); ret = true; break;
 2014                }
 2015                case LE_STR7('V','a','l','u','e','5','4'): {
 2016                    value_SetEnum(parent,fasttest_FieldId_Value54); ret = true; break;
 2017                }
 2018                case LE_STR7('V','a','l','u','e','5','5'): {
 2019                    value_SetEnum(parent,fasttest_FieldId_Value55); ret = true; break;
 2020                }
 2021                case LE_STR7('V','a','l','u','e','5','6'): {
 2022                    value_SetEnum(parent,fasttest_FieldId_Value56); ret = true; break;
 2023                }
 2024                case LE_STR7('V','a','l','u','e','5','7'): {
 2025                    value_SetEnum(parent,fasttest_FieldId_Value57); ret = true; break;
 2026                }
 2027                case LE_STR7('V','a','l','u','e','5','8'): {
 2028                    value_SetEnum(parent,fasttest_FieldId_Value58); ret = true; break;
 2029                }
 2030                case LE_STR7('V','a','l','u','e','5','9'): {
 2031                    value_SetEnum(parent,fasttest_FieldId_Value59); ret = true; break;
 2032                }
 2033                case LE_STR7('V','a','l','u','e','6','0'): {
 2034                    value_SetEnum(parent,fasttest_FieldId_Value60); ret = true; break;
 2035                }
 2036                case LE_STR7('V','a','l','u','e','6','1'): {
 2037                    value_SetEnum(parent,fasttest_FieldId_Value61); ret = true; break;
 2038                }
 2039                case LE_STR7('V','a','l','u','e','6','2'): {
 2040                    value_SetEnum(parent,fasttest_FieldId_Value62); ret = true; break;
 2041                }
 2042                case LE_STR7('V','a','l','u','e','6','3'): {
 2043                    value_SetEnum(parent,fasttest_FieldId_Value63); ret = true; break;
 2044                }
 2045                case LE_STR7('V','a','l','u','e','6','5'): {
 2046                    value_SetEnum(parent,fasttest_FieldId_Value65); ret = true; break;
 2047                }
 2048                case LE_STR7('V','a','l','u','e','6','6'): {
 2049                    value_SetEnum(parent,fasttest_FieldId_Value66); ret = true; break;
 2050                }
 2051                case LE_STR7('V','a','l','u','e','6','7'): {
 2052                    value_SetEnum(parent,fasttest_FieldId_Value67); ret = true; break;
 2053                }
 2054                case LE_STR7('V','a','l','u','e','6','8'): {
 2055                    value_SetEnum(parent,fasttest_FieldId_Value68); ret = true; break;
 2056                }
 2057                case LE_STR7('V','a','l','u','e','6','9'): {
 2058                    value_SetEnum(parent,fasttest_FieldId_Value69); ret = true; break;
 2059                }
 2060                case LE_STR7('V','a','l','u','e','7','0'): {
 2061                    value_SetEnum(parent,fasttest_FieldId_Value70); ret = true; break;
 2062                }
 2063                case LE_STR7('V','a','l','u','e','7','1'): {
 2064                    value_SetEnum(parent,fasttest_FieldId_Value71); ret = true; break;
 2065                }
 2066                case LE_STR7('V','a','l','u','e','7','2'): {
 2067                    value_SetEnum(parent,fasttest_FieldId_Value72); ret = true; break;
 2068                }
 2069                case LE_STR7('V','a','l','u','e','8','1'): {
 2070                    value_SetEnum(parent,fasttest_FieldId_Value81); ret = true; break;
 2071                }
 2072                case LE_STR7('V','a','l','u','e','8','2'): {
 2073                    value_SetEnum(parent,fasttest_FieldId_Value82); ret = true; break;
 2074                }
 2075                case LE_STR7('V','a','l','u','e','8','3'): {
 2076                    value_SetEnum(parent,fasttest_FieldId_Value83); ret = true; break;
 2077                }
 2078                case LE_STR7('V','a','l','u','e','8','4'): {
 2079                    value_SetEnum(parent,fasttest_FieldId_Value84); ret = true; break;
 2080                }
 2081                case LE_STR7('V','a','l','u','e','9','7'): {
 2082                    value_SetEnum(parent,fasttest_FieldId_Value97); ret = true; break;
 2083                }
 2084                case LE_STR7('V','a','l','u','e','9','8'): {
 2085                    value_SetEnum(parent,fasttest_FieldId_Value98); ret = true; break;
 2086                }
 2087                case LE_STR7('V','a','l','u','e','9','9'): {
 2088                    value_SetEnum(parent,fasttest_FieldId_Value99); ret = true; break;
 2089                }
 2090                case LE_STR7('s','e','c','u','n','d','a'): {
 2091                    value_SetEnum(parent,fasttest_FieldId_secunda); ret = true; break;
 2092                }
 2093            }
 2094            break;
 2095        }
 2096        case 8: {
 2097            switch (algo::ReadLE64(rhs.elems)) {
 2098                case LE_STR8('F','i','r','s','t','S','e','q'): {
 2099                    value_SetEnum(parent,fasttest_FieldId_FirstSeq); ret = true; break;
 2100                }
 2101                case LE_STR8('V','a','l','u','e','1','0','0'): {
 2102                    value_SetEnum(parent,fasttest_FieldId_Value100); ret = true; break;
 2103                }
 2104                case LE_STR8('V','a','l','u','e','1','0','1'): {
 2105                    value_SetEnum(parent,fasttest_FieldId_Value101); ret = true; break;
 2106                }
 2107                case LE_STR8('V','a','l','u','e','1','0','2'): {
 2108                    value_SetEnum(parent,fasttest_FieldId_Value102); ret = true; break;
 2109                }
 2110                case LE_STR8('V','a','l','u','e','1','0','3'): {
 2111                    value_SetEnum(parent,fasttest_FieldId_Value103); ret = true; break;
 2112                }
 2113                case LE_STR8('V','a','l','u','e','1','0','4'): {
 2114                    value_SetEnum(parent,fasttest_FieldId_Value104); ret = true; break;
 2115                }
 2116                case LE_STR8('V','a','l','u','e','1','4','7'): {
 2117                    value_SetEnum(parent,fasttest_FieldId_Value147); ret = true; break;
 2118                }
 2119                case LE_STR8('V','a','l','u','e','1','5','0'): {
 2120                    value_SetEnum(parent,fasttest_FieldId_Value150); ret = true; break;
 2121                }
 2122            }
 2123            break;
 2124        }
 2125        case 9: {
 2126            switch (algo::ReadLE64(rhs.elems)) {
 2127                case LE_STR8('O','p','t','S','g','m','G','r'): {
 2128                    if (memcmp(rhs.elems+8,"p",1)==0) { value_SetEnum(parent,fasttest_FieldId_OptSgmGrp); ret = true; break; }
 2129                    break;
 2130                }
 2131                case LE_STR8('O','p','t','S','g','m','S','e'): {
 2132                    if (memcmp(rhs.elems+8,"q",1)==0) { value_SetEnum(parent,fasttest_FieldId_OptSgmSeq); ret = true; break; }
 2133                    break;
 2134                }
 2135                case LE_STR8('O','p','t','T','r','v','G','r'): {
 2136                    if (memcmp(rhs.elems+8,"p",1)==0) { value_SetEnum(parent,fasttest_FieldId_OptTrvGrp); ret = true; break; }
 2137                    break;
 2138                }
 2139                case LE_STR8('O','p','t','T','r','v','S','e'): {
 2140                    if (memcmp(rhs.elems+8,"q",1)==0) { value_SetEnum(parent,fasttest_FieldId_OptTrvSeq); ret = true; break; }
 2141                    break;
 2142                }
 2143                case LE_STR8('S','e','c','o','n','d','S','e'): {
 2144                    if (memcmp(rhs.elems+8,"q",1)==0) { value_SetEnum(parent,fasttest_FieldId_SecondSeq); ret = true; break; }
 2145                    break;
 2146                }
 2147            }
 2148            break;
 2149        }
 2150        case 13: {
 2151            switch (algo::ReadLE64(rhs.elems)) {
 2152                case LE_STR8('T','r','v','S','e','q','D','f'): {
 2153                    if (memcmp(rhs.elems+8,"ltOpt",5)==0) { value_SetEnum(parent,fasttest_FieldId_TrvSeqDfltOpt); ret = true; break; }
 2154                    break;
 2155                }
 2156                case LE_STR8('T','r','v','S','e','q','L','e'): {
 2157                    if (memcmp(rhs.elems+8,"nDflt",5)==0) { value_SetEnum(parent,fasttest_FieldId_TrvSeqLenDflt); ret = true; break; }
 2158                    if (memcmp(rhs.elems+8,"nNone",5)==0) { value_SetEnum(parent,fasttest_FieldId_TrvSeqLenNone); ret = true; break; }
 2159                    break;
 2160                }
 2161            }
 2162            break;
 2163        }
 2164        case 14: {
 2165            switch (algo::ReadLE64(rhs.elems)) {
 2166                case LE_STR8('T','r','v','S','e','q','L','e'): {
 2167                    if (memcmp(rhs.elems+8,"nConst",6)==0) { value_SetEnum(parent,fasttest_FieldId_TrvSeqLenConst); ret = true; break; }
 2168                    break;
 2169                }
 2170            }
 2171            break;
 2172        }
 2173        case 16: {
 2174            switch (algo::ReadLE64(rhs.elems)) {
 2175                case LE_STR8('T','r','v','S','e','q','L','e'): {
 2176                    if (memcmp(rhs.elems+8,"nNoneOpt",8)==0) { value_SetEnum(parent,fasttest_FieldId_TrvSeqLenNoneOpt); ret = true; break; }
 2177                    break;
 2178                }
 2179            }
 2180            break;
 2181        }
 2182        case 17: {
 2183            switch (algo::ReadLE64(rhs.elems)) {
 2184                case LE_STR8('T','r','v','S','e','q','L','e'): {
 2185                    if (memcmp(rhs.elems+8,"nConstOpt",9)==0) { value_SetEnum(parent,fasttest_FieldId_TrvSeqLenConstOpt); ret = true; break; }
 2186                    break;
 2187                }
 2188            }
 2189            break;
 2190        }
 2191    }
 2192    return ret;
 2193}
 2194
 2195// --- fasttest.FieldId.value.SetStrptr
 2196// Convert string to field.
 2197// If the string is invalid, set numeric value to DFLT
 2198void fasttest::value_SetStrptr(fasttest::FieldId& parent, algo::strptr rhs, fasttest_FieldIdEnum dflt) {
 2199    if (!value_SetStrptrMaybe(parent,rhs)) value_SetEnum(parent,dflt);
 2200}
 2201
 2202// --- fasttest.FieldId.value.ReadStrptrMaybe
 2203// Convert string to field. Return success value
 2204bool fasttest::value_ReadStrptrMaybe(fasttest::FieldId& parent, algo::strptr rhs) {
 2205    bool retval = false;
 2206    retval = value_SetStrptrMaybe(parent,rhs); // try symbol conversion
 2207    if (!retval) { // didn't work? try reading as underlying type
 2208        retval = i32_ReadStrptrMaybe(parent.value,rhs);
 2209    }
 2210    return retval;
 2211}
 2212
 2213// --- fasttest.FieldId..ReadStrptrMaybe
 2214// Read fields of fasttest::FieldId from an ascii string.
 2215// The format of the string is the format of the fasttest::FieldId's only field
 2216bool fasttest::FieldId_ReadStrptrMaybe(fasttest::FieldId &parent, algo::strptr in_str) {
 2217    bool retval = true;
 2218    retval = retval && value_ReadStrptrMaybe(parent, in_str);
 2219    return retval;
 2220}
 2221
 2222// --- fasttest.FieldId..Print
 2223// print string representation of ROW to string STR
 2224// cfmt:fasttest.FieldId.String  printfmt:Raw
 2225void fasttest::FieldId_Print(fasttest::FieldId& row, algo::cstring& str) {
 2226    fasttest::value_Print(row, str);
 2227}
 2228
 2229// --- fasttest.FirstSeq..ReadFieldMaybe
 2230bool fasttest::FirstSeq_ReadFieldMaybe(fasttest::FirstSeq& parent, algo::strptr field, algo::strptr strval) {
 2231    bool retval = true;
 2232    fasttest::FieldId field_id;
 2233    (void)value_SetStrptrMaybe(field_id,field);
 2234    switch(field_id) {
 2235        case fasttest_FieldId_Value1: {
 2236            retval = u32_ReadStrptrMaybe(parent.Value1, strval);
 2237            break;
 2238        }
 2239        default: break;
 2240    }
 2241    if (!retval) {
 2242        algo_lib::AppendErrtext("attr",field);
 2243    }
 2244    return retval;
 2245}
 2246
 2247// --- fasttest.FirstSeq..ReadStrptrMaybe
 2248// Read fields of fasttest::FirstSeq from an ascii string.
 2249// The format of the string is an ssim Tuple
 2250bool fasttest::FirstSeq_ReadStrptrMaybe(fasttest::FirstSeq &parent, algo::strptr in_str) {
 2251    bool retval = true;
 2252    retval = algo::StripTypeTag(in_str, "fasttest.FirstSeq");
 2253    ind_beg(algo::Attr_curs, attr, in_str) {
 2254        retval = retval && FirstSeq_ReadFieldMaybe(parent, attr.name, attr.value);
 2255    }ind_end;
 2256    return retval;
 2257}
 2258
 2259// --- fasttest.FirstSeq..Print
 2260// print string representation of ROW to string STR
 2261// cfmt:fasttest.FirstSeq.String  printfmt:Tuple
 2262void fasttest::FirstSeq_Print(fasttest::FirstSeq& row, algo::cstring& str) {
 2263    algo::tempstr temp;
 2264    str << "fasttest.FirstSeq";
 2265
 2266    u32_Print(row.Value1, temp);
 2267    PrintAttrSpaceReset(str,"Value1", temp);
 2268}
 2269
 2270// --- fasttest.FirstSeq..FastEncode
 2271void fasttest::FirstSeq_FastEncode(algo::ByteAry& buf, FastState& state, fasttest::FirstSeq& parent) {
 2272    // Value1 unsigned none mandatory
 2273    lib_fast::EncodeUnsigned(buf,parent.Value1,false);
 2274    (void)state;//only to avoid -Wunused-parameter
 2275}
 2276
 2277// --- fasttest.FirstSeq..FastDecode
 2278bool fasttest::FirstSeq_FastDecode(algo::memptr& from, FastState& state, fasttest::FirstSeq& parent) {
 2279    bool ok = true;
 2280    // Value1 unsigned none mandatory
 2281    if (ok) {
 2282        ok = lib_fast::DecodeUnsigned(from,parent.Value1,false);
 2283        if (!ok) {
 2284            state.error << "fasttest.FirstSeq.Value1: bad Unsigned" << eol;
 2285        }
 2286    }
 2287    return ok;
 2288}
 2289
 2290// --- fasttest.FirstSeq..FixEncode
 2291void fasttest::FirstSeq_FixEncode(cstring& buf, fasttest::FirstSeq& parent, char soh) {
 2292    buf << "2=" << parent.Value1 << soh;
 2293}
 2294
 2295// --- fasttest.OptSgmGrp..ReadFieldMaybe
 2296bool fasttest::OptSgmGrp_ReadFieldMaybe(fasttest::OptSgmGrp& parent, algo::strptr field, algo::strptr strval) {
 2297    bool retval = true;
 2298    fasttest::FieldId field_id;
 2299    (void)value_SetStrptrMaybe(field_id,field);
 2300    switch(field_id) {
 2301        case fasttest_FieldId_Value: {
 2302            retval = u32_ReadStrptrMaybe(parent.Value, strval);
 2303            break;
 2304        }
 2305        default: break;
 2306    }
 2307    if (!retval) {
 2308        algo_lib::AppendErrtext("attr",field);
 2309    }
 2310    return retval;
 2311}
 2312
 2313// --- fasttest.OptSgmGrp..ReadStrptrMaybe
 2314// Read fields of fasttest::OptSgmGrp from an ascii string.
 2315// The format of the string is an ssim Tuple
 2316bool fasttest::OptSgmGrp_ReadStrptrMaybe(fasttest::OptSgmGrp &parent, algo::strptr in_str) {
 2317    bool retval = true;
 2318    retval = algo::StripTypeTag(in_str, "fasttest.OptSgmGrp");
 2319    ind_beg(algo::Attr_curs, attr, in_str) {
 2320        retval = retval && OptSgmGrp_ReadFieldMaybe(parent, attr.name, attr.value);
 2321    }ind_end;
 2322    return retval;
 2323}
 2324
 2325// --- fasttest.OptSgmGrp..Print
 2326// print string representation of ROW to string STR
 2327// cfmt:fasttest.OptSgmGrp.String  printfmt:Tuple
 2328void fasttest::OptSgmGrp_Print(fasttest::OptSgmGrp& row, algo::cstring& str) {
 2329    algo::tempstr temp;
 2330    str << "fasttest.OptSgmGrp";
 2331
 2332    u32_Print(row.Value, temp);
 2333    PrintAttrSpaceReset(str,"Value", temp);
 2334}
 2335
 2336// --- fasttest.OptSgmGrp..FastEncode
 2337void fasttest::OptSgmGrp_FastEncode(algo::ByteAry& buf, FastState& state, fasttest::OptSgmGrp& parent) {
 2338    int index = ary_N(buf);
 2339    u64 pmap(0);
 2340    // Value unsigned default mandatory
 2341    if (parent.Value != 1) {
 2342        lib_fast::EncodeUnsigned(buf,parent.Value,false);
 2343        lib_fast::SetPmapBit(pmap,0);
 2344    }
 2345    lib_fast::InsertPmap(buf,index,pmap);
 2346    (void)state;//only to avoid -Wunused-parameter
 2347}
 2348
 2349// --- fasttest.OptSgmGrp..FastDecode
 2350bool fasttest::OptSgmGrp_FastDecode(algo::memptr& from, FastState& state, fasttest::OptSgmGrp& parent) {
 2351    bool ok = true;
 2352    u64 pmap;
 2353    ok = lib_fast::DecodePmap(from,pmap);
 2354    if (!ok) {
 2355        state.error << "fasttest.OptSgmGrp: bad pmap" << eol;
 2356    }
 2357    // Value unsigned default mandatory
 2358    if (ok) {
 2359        bool prs = lib_fast::GetPmapBit(pmap,0);
 2360        if (prs) {
 2361            ok = lib_fast::DecodeUnsigned(from,parent.Value,false);
 2362            if (!ok) {
 2363                state.error << "fasttest.OptSgmGrp.Value: bad Unsigned" << eol;
 2364            }
 2365        } else {
 2366            parent.Value = 1;
 2367        }
 2368    }
 2369    return ok;
 2370}
 2371
 2372// --- fasttest.OptSgmGrp..FixEncode
 2373void fasttest::OptSgmGrp_FixEncode(cstring& buf, fasttest::OptSgmGrp& parent, char soh) {
 2374    buf << "2=" << parent.Value << soh;
 2375}
 2376
 2377// --- fasttest.GroupSgmOpt.base.CopyOut
 2378// Copy fields out of row
 2379void fasttest::parent_CopyOut(fasttest::GroupSgmOpt &row, fasttest::TemplateHeader &out) {
 2380    // length: field value is computed
 2381    // id: field value is computed
 2382    (void)row;//only to avoid -Wunused-parameter
 2383    (void)out;//only to avoid -Wunused-parameter
 2384}
 2385
 2386// --- fasttest.GroupSgmOpt.OptSgmGrp.ReadStrptrMaybe
 2387inline static bool fasttest::OptSgmGrp_ReadStrptrMaybe(fasttest::GroupSgmOpt &parent, algo::strptr in_str) {
 2388    bool retval = true;
 2389    fasttest::OptSgmGrp OptSgmGrp_tmp;
 2390    retval = fasttest::OptSgmGrp_ReadStrptrMaybe(OptSgmGrp_tmp, in_str);
 2391    if (retval) {
 2392        OptSgmGrp_Set(parent, OptSgmGrp_tmp);
 2393    }
 2394    return retval;
 2395}
 2396
 2397// --- fasttest.GroupSgmOpt.pmask_bitcurs.Next
 2398// proceed to next item
 2399void fasttest::GroupSgmOpt_pmask_bitcurs_Next(GroupSgmOpt_pmask_bitcurs &curs) {
 2400    ++curs.bit;
 2401    int index = curs.bit / 32;
 2402    int offset = curs.bit % 32;
 2403    for (; index < curs.n_elems; ++index, offset = 0) {
 2404        u64 rest = curs.elems[index] >> offset;
 2405        if (rest) {
 2406            offset += algo::u64_BitScanForward(rest);
 2407            break;
 2408        }
 2409    }
 2410    curs.bit = index * 32 + offset;
 2411}
 2412
 2413// --- fasttest.GroupSgmOpt..ReadFieldMaybe
 2414bool fasttest::GroupSgmOpt_ReadFieldMaybe(fasttest::GroupSgmOpt& parent, algo::strptr field, algo::strptr strval) {
 2415    bool retval = true;
 2416    fasttest::FieldId field_id;
 2417    (void)value_SetStrptrMaybe(field_id,field);
 2418    switch(field_id) {
 2419        case fasttest_FieldId_base: {
 2420            retval = false;
 2421            break;
 2422        }
 2423        case fasttest_FieldId_length: {
 2424            retval = false;
 2425            break;
 2426        }
 2427        case fasttest_FieldId_id: {
 2428            retval = false;
 2429            break;
 2430        }
 2431        case fasttest_FieldId_pmask: {
 2432            retval = false;
 2433            break;
 2434        }
 2435        case fasttest_FieldId_OptSgmGrp: {
 2436            retval = OptSgmGrp_ReadStrptrMaybe(parent, strval);
 2437            if (retval) {
 2438                pmask_qSetBit(parent, 0);
 2439            }
 2440            break;
 2441        }
 2442        default: break;
 2443    }
 2444    if (!retval) {
 2445        algo_lib::AppendErrtext("attr",field);
 2446    }
 2447    return retval;
 2448}
 2449
 2450// --- fasttest.GroupSgmOpt..ReadStrptrMaybe
 2451// Read fields of fasttest::GroupSgmOpt from an ascii string.
 2452// The format of the string is an ssim Tuple
 2453bool fasttest::GroupSgmOpt_ReadStrptrMaybe(fasttest::GroupSgmOpt &parent, algo::strptr in_str) {
 2454    bool retval = true;
 2455    retval = algo::StripTypeTag(in_str, "fasttest.GroupSgmOpt");
 2456    ind_beg(algo::Attr_curs, attr, in_str) {
 2457        retval = retval && GroupSgmOpt_ReadFieldMaybe(parent, attr.name, attr.value);
 2458    }ind_end;
 2459    return retval;
 2460}
 2461
 2462// --- fasttest.GroupSgmOpt..Print
 2463// print string representation of ROW to string STR
 2464// cfmt:fasttest.GroupSgmOpt.String  printfmt:Tuple
 2465void fasttest::GroupSgmOpt_Print(fasttest::GroupSgmOpt& row, algo::cstring& str) {
 2466    algo::tempstr temp;
 2467    str << "fasttest.GroupSgmOpt";
 2468
 2469    if (OptSgmGrp_PresentQ(row)) {
 2470        fasttest::OptSgmGrp_Print(row.OptSgmGrp, temp);
 2471        PrintAttrSpaceReset(str,"OptSgmGrp", temp);
 2472    }
 2473}
 2474
 2475// --- fasttest.GroupSgmOpt..FastEncode
 2476void fasttest::GroupSgmOpt_FastEncode(algo::ByteAry& buf, FastState& state, fasttest::GroupSgmOpt& parent) {
 2477    int index = ary_N(buf);
 2478    u64 pmap(0);
 2479    if (!tid_AssignedQ(state) || parent.id != state.tid) {
 2480        lib_fast::EncodeUnsigned(buf,parent.id,false);
 2481        lib_fast::SetPmapBit(pmap,0);
 2482    }
 2483    tid_SetAssigned(state);
 2484    state.tid = parent.id;
 2485    // OptSgmGrp group none optional
 2486    if (OptSgmGrp_PresentQ(parent)) {
 2487        OptSgmGrp_FastEncode(buf,state,parent.OptSgmGrp);
 2488        lib_fast::SetPmapBit(pmap,1);
 2489    }
 2490    lib_fast::InsertPmap(buf,index,pmap);
 2491}
 2492
 2493// --- fasttest.GroupSgmOpt..FastDecode
 2494bool fasttest::GroupSgmOpt_FastDecode(algo::memptr& from, u64 pmap, FastState& state, fasttest::GroupSgmOpt& parent) {
 2495    bool ok = true;
 2496    // OptSgmGrp group none optional
 2497    if (ok) {
 2498        bool prs = lib_fast::GetPmapBit(pmap,1);
 2499        pmask_qSetBitVal(parent,OptSgmGrp_Present_GetBit(parent),prs);
 2500        if (prs) {
 2501            ok = OptSgmGrp_FastDecode(from,state,parent.OptSgmGrp);
 2502        }
 2503    }
 2504    return ok;
 2505}
 2506
 2507// --- fasttest.GroupSgmOpt..FixEncode
 2508void fasttest::GroupSgmOpt_FixEncode(cstring& buf, fasttest::GroupSgmOpt& parent, char soh) {
 2509    if (OptSgmGrp_PresentQ(parent)) {
 2510        OptSgmGrp_FixEncode(buf,parent.OptSgmGrp,soh);
 2511    }
 2512}
 2513
 2514// --- fasttest.TrvGrp..ReadFieldMaybe
 2515bool fasttest::TrvGrp_ReadFieldMaybe(fasttest::TrvGrp& parent, algo::strptr field, algo::strptr strval) {
 2516    bool retval = true;
 2517    fasttest::FieldId field_id;
 2518    (void)value_SetStrptrMaybe(field_id,field);
 2519    switch(field_id) {
 2520        case fasttest_FieldId_Value: {
 2521            retval = u32_ReadStrptrMaybe(parent.Value, strval);
 2522            break;
 2523        }
 2524        default: break;
 2525    }
 2526    if (!retval) {
 2527        algo_lib::AppendErrtext("attr",field);
 2528    }
 2529    return retval;
 2530}
 2531
 2532// --- fasttest.TrvGrp..ReadStrptrMaybe
 2533// Read fields of fasttest::TrvGrp from an ascii string.
 2534// The format of the string is an ssim Tuple
 2535bool fasttest::TrvGrp_ReadStrptrMaybe(fasttest::TrvGrp &parent, algo::strptr in_str) {
 2536    bool retval = true;
 2537    retval = algo::StripTypeTag(in_str, "fasttest.TrvGrp");
 2538    ind_beg(algo::Attr_curs, attr, in_str) {
 2539        retval = retval && TrvGrp_ReadFieldMaybe(parent, attr.name, attr.value);
 2540    }ind_end;
 2541    return retval;
 2542}
 2543
 2544// --- fasttest.TrvGrp..Print
 2545// print string representation of ROW to string STR
 2546// cfmt:fasttest.TrvGrp.String  printfmt:Tuple
 2547void fasttest::TrvGrp_Print(fasttest::TrvGrp& row, algo::cstring& str) {
 2548    algo::tempstr temp;
 2549    str << "fasttest.TrvGrp";
 2550
 2551    u32_Print(row.Value, temp);
 2552    PrintAttrSpaceReset(str,"Value", temp);
 2553}
 2554
 2555// --- fasttest.TrvGrp..FastEncode
 2556void fasttest::TrvGrp_FastEncode(algo::ByteAry& buf, FastState& state, fasttest::TrvGrp& parent) {
 2557    // Value unsigned none mandatory
 2558    lib_fast::EncodeUnsigned(buf,parent.Value,false);
 2559    (void)state;//only to avoid -Wunused-parameter
 2560}
 2561
 2562// --- fasttest.TrvGrp..FastDecode
 2563bool fasttest::TrvGrp_FastDecode(algo::memptr& from, FastState& state, fasttest::TrvGrp& parent) {
 2564    bool ok = true;
 2565    // Value unsigned none mandatory
 2566    if (ok) {
 2567        ok = lib_fast::DecodeUnsigned(from,parent.Value,false);
 2568        if (!ok) {
 2569            state.error << "fasttest.TrvGrp.Value: bad Unsigned" << eol;
 2570        }
 2571    }
 2572    return ok;
 2573}
 2574
 2575// --- fasttest.TrvGrp..FixEncode
 2576void fasttest::TrvGrp_FixEncode(cstring& buf, fasttest::TrvGrp& parent, char soh) {
 2577    buf << "2=" << parent.Value << soh;
 2578}
 2579
 2580// --- fasttest.GroupTrv.base.CopyOut
 2581// Copy fields out of row
 2582void fasttest::parent_CopyOut(fasttest::GroupTrv &row, fasttest::TemplateHeader &out) {
 2583    // length: field value is computed
 2584    // id: field value is computed
 2585    (void)row;//only to avoid -Wunused-parameter
 2586    (void)out;//only to avoid -Wunused-parameter
 2587}
 2588
 2589// --- fasttest.GroupTrv..ReadFieldMaybe
 2590bool fasttest::GroupTrv_ReadFieldMaybe(fasttest::GroupTrv& parent, algo::strptr field, algo::strptr strval) {
 2591    bool retval = true;
 2592    fasttest::FieldId field_id;
 2593    (void)value_SetStrptrMaybe(field_id,field);
 2594    switch(field_id) {
 2595        case fasttest_FieldId_base: {
 2596            retval = false;
 2597            break;
 2598        }
 2599        case fasttest_FieldId_length: {
 2600            retval = false;
 2601            break;
 2602        }
 2603        case fasttest_FieldId_id: {
 2604            retval = false;
 2605            break;
 2606        }
 2607        case fasttest_FieldId_TrvGrp: {
 2608            retval = fasttest::TrvGrp_ReadStrptrMaybe(parent.TrvGrp, strval);
 2609            break;
 2610        }
 2611        default: break;
 2612    }
 2613    if (!retval) {
 2614        algo_lib::AppendErrtext("attr",field);
 2615    }
 2616    return retval;
 2617}
 2618
 2619// --- fasttest.GroupTrv..ReadStrptrMaybe
 2620// Read fields of fasttest::GroupTrv from an ascii string.
 2621// The format of the string is an ssim Tuple
 2622bool fasttest::GroupTrv_ReadStrptrMaybe(fasttest::GroupTrv &parent, algo::strptr in_str) {
 2623    bool retval = true;
 2624    retval = algo::StripTypeTag(in_str, "fasttest.GroupTrv");
 2625    ind_beg(algo::Attr_curs, attr, in_str) {
 2626        retval = retval && GroupTrv_ReadFieldMaybe(parent, attr.name, attr.value);
 2627    }ind_end;
 2628    return retval;
 2629}
 2630
 2631// --- fasttest.GroupTrv..Print
 2632// print string representation of ROW to string STR
 2633// cfmt:fasttest.GroupTrv.String  printfmt:Tuple
 2634void fasttest::GroupTrv_Print(fasttest::GroupTrv& row, algo::cstring& str) {
 2635    algo::tempstr temp;
 2636    str << "fasttest.GroupTrv";
 2637
 2638    fasttest::TrvGrp_Print(row.TrvGrp, temp);
 2639    PrintAttrSpaceReset(str,"TrvGrp", temp);
 2640}
 2641
 2642// --- fasttest.GroupTrv..FastEncode
 2643void fasttest::GroupTrv_FastEncode(algo::ByteAry& buf, FastState& state, fasttest::GroupTrv& parent) {
 2644    int index = ary_N(buf);
 2645    u64 pmap(0);
 2646    if (!tid_AssignedQ(state) || parent.id != state.tid) {
 2647        lib_fast::EncodeUnsigned(buf,parent.id,false);
 2648        lib_fast::SetPmapBit(pmap,0);
 2649    }
 2650    tid_SetAssigned(state);
 2651    state.tid = parent.id;
 2652    // TrvGrp group none mandatory
 2653    TrvGrp_FastEncode(buf,state,parent.TrvGrp);
 2654    lib_fast::InsertPmap(buf,index,pmap);
 2655}
 2656
 2657// --- fasttest.GroupTrv..FastDecode
 2658bool fasttest::GroupTrv_FastDecode(algo::memptr& from, u64 pmap, FastState& state, fasttest::GroupTrv& parent) {
 2659    bool ok = true;
 2660    // TrvGrp group none mandatory
 2661    if (ok) {
 2662        ok = TrvGrp_FastDecode(from,state,parent.TrvGrp);
 2663    }
 2664    (void)pmap;//only to avoid -Wunused-parameter
 2665    return ok;
 2666}
 2667
 2668// --- fasttest.GroupTrv..FixEncode
 2669void fasttest::GroupTrv_FixEncode(cstring& buf, fasttest::GroupTrv& parent, char soh) {
 2670    TrvGrp_FixEncode(buf,parent.TrvGrp, soh);
 2671}
 2672
 2673// --- fasttest.OptTrvGrp..ReadFieldMaybe
 2674bool fasttest::OptTrvGrp_ReadFieldMaybe(fasttest::OptTrvGrp& parent, algo::strptr field, algo::strptr strval) {
 2675    bool retval = true;
 2676    fasttest::FieldId field_id;
 2677    (void)value_SetStrptrMaybe(field_id,field);
 2678    switch(field_id) {
 2679        case fasttest_FieldId_Value: {
 2680            retval = u32_ReadStrptrMaybe(parent.Value, strval);
 2681            break;
 2682        }
 2683        default: break;
 2684    }
 2685    if (!retval) {
 2686        algo_lib::AppendErrtext("attr",field);
 2687    }
 2688    return retval;
 2689}
 2690
 2691// --- fasttest.OptTrvGrp..ReadStrptrMaybe
 2692// Read fields of fasttest::OptTrvGrp from an ascii string.
 2693// The format of the string is an ssim Tuple
 2694bool fasttest::OptTrvGrp_ReadStrptrMaybe(fasttest::OptTrvGrp &parent, algo::strptr in_str) {
 2695    bool retval = true;
 2696    retval = algo::StripTypeTag(in_str, "fasttest.OptTrvGrp");
 2697    ind_beg(algo::Attr_curs, attr, in_str) {
 2698        retval = retval && OptTrvGrp_ReadFieldMaybe(parent, attr.name, attr.value);
 2699    }ind_end;
 2700    return retval;
 2701}
 2702
 2703// --- fasttest.OptTrvGrp..Print
 2704// print string representation of ROW to string STR
 2705// cfmt:fasttest.OptTrvGrp.String  printfmt:Tuple
 2706void fasttest::OptTrvGrp_Print(fasttest::OptTrvGrp& row, algo::cstring& str) {
 2707    algo::tempstr temp;
 2708    str << "fasttest.OptTrvGrp";
 2709
 2710    u32_Print(row.Value, temp);
 2711    PrintAttrSpaceReset(str,"Value", temp);
 2712}
 2713
 2714// --- fasttest.OptTrvGrp..FastEncode
 2715void fasttest::OptTrvGrp_FastEncode(algo::ByteAry& buf, FastState& state, fasttest::OptTrvGrp& parent) {
 2716    // Value unsigned none mandatory
 2717    lib_fast::EncodeUnsigned(buf,parent.Value,false);
 2718    (void)state;//only to avoid -Wunused-parameter
 2719}
 2720
 2721// --- fasttest.OptTrvGrp..FastDecode
 2722bool fasttest::OptTrvGrp_FastDecode(algo::memptr& from, FastState& state, fasttest::OptTrvGrp& parent) {
 2723    bool ok = true;
 2724    // Value unsigned none mandatory
 2725    if (ok) {
 2726        ok = lib_fast::DecodeUnsigned(from,parent.Value,false);
 2727        if (!ok) {
 2728            state.error << "fasttest.OptTrvGrp.Value: bad Unsigned" << eol;
 2729        }
 2730    }
 2731    return ok;
 2732}
 2733
 2734// --- fasttest.OptTrvGrp..FixEncode
 2735void fasttest::OptTrvGrp_FixEncode(cstring& buf, fasttest::OptTrvGrp& parent, char soh) {
 2736    buf << "2=" << parent.Value << soh;
 2737}
 2738
 2739// --- fasttest.GroupTrvOpt.base.CopyOut
 2740// Copy fields out of row
 2741void fasttest::parent_CopyOut(fasttest::GroupTrvOpt &row, fasttest::TemplateHeader &out) {
 2742    // length: field value is computed
 2743    // id: field value is computed
 2744    (void)row;//only to avoid -Wunused-parameter
 2745    (void)out;//only to avoid -Wunused-parameter
 2746}
 2747
 2748// --- fasttest.GroupTrvOpt.OptTrvGrp.ReadStrptrMaybe
 2749inline static bool fasttest::OptTrvGrp_ReadStrptrMaybe(fasttest::GroupTrvOpt &parent, algo::strptr in_str) {
 2750    bool retval = true;
 2751    fasttest::OptTrvGrp OptTrvGrp_tmp;
 2752    retval = fasttest::OptTrvGrp_ReadStrptrMaybe(OptTrvGrp_tmp, in_str);
 2753    if (retval) {
 2754        OptTrvGrp_Set(parent, OptTrvGrp_tmp);
 2755    }
 2756    return retval;
 2757}
 2758
 2759// --- fasttest.GroupTrvOpt.pmask_bitcurs.Next
 2760// proceed to next item
 2761void fasttest::GroupTrvOpt_pmask_bitcurs_Next(GroupTrvOpt_pmask_bitcurs &curs) {
 2762    ++curs.bit;
 2763    int index = curs.bit / 32;
 2764    int offset = curs.bit % 32;
 2765    for (; index < curs.n_elems; ++index, offset = 0) {
 2766        u64 rest = curs.elems[index] >> offset;
 2767        if (rest) {
 2768            offset += algo::u64_BitScanForward(rest);
 2769            break;
 2770        }
 2771    }
 2772    curs.bit = index * 32 + offset;
 2773}
 2774
 2775// --- fasttest.GroupTrvOpt..ReadFieldMaybe
 2776bool fasttest::GroupTrvOpt_ReadFieldMaybe(fasttest::GroupTrvOpt& parent, algo::strptr field, algo::strptr strval) {
 2777    bool retval = true;
 2778    fasttest::FieldId field_id;
 2779    (void)value_SetStrptrMaybe(field_id,field);
 2780    switch(field_id) {
 2781        case fasttest_FieldId_base: {
 2782            retval = false;
 2783            break;
 2784        }
 2785        case fasttest_FieldId_length: {
 2786            retval = false;
 2787            break;
 2788        }
 2789        case fasttest_FieldId_id: {
 2790            retval = false;
 2791            break;
 2792        }
 2793        case fasttest_FieldId_pmask: {
 2794            retval = false;
 2795            break;
 2796        }
 2797        case fasttest_FieldId_OptTrvGrp: {
 2798            retval = OptTrvGrp_ReadStrptrMaybe(parent, strval);
 2799            if (retval) {
 2800                pmask_qSetBit(parent, 0);
 2801            }
 2802            break;
 2803        }
 2804        default: break;
 2805    }
 2806    if (!retval) {
 2807        algo_lib::AppendErrtext("attr",field);
 2808    }
 2809    return retval;
 2810}
 2811
 2812// --- fasttest.GroupTrvOpt..ReadStrptrMaybe
 2813// Read fields of fasttest::GroupTrvOpt from an ascii string.
 2814// The format of the string is an ssim Tuple
 2815bool fasttest::GroupTrvOpt_ReadStrptrMaybe(fasttest::GroupTrvOpt &parent, algo::strptr in_str) {
 2816    bool retval = true;
 2817    retval = algo::StripTypeTag(in_str, "fasttest.GroupTrvOpt");
 2818    ind_beg(algo::Attr_curs, attr, in_str) {
 2819        retval = retval && GroupTrvOpt_ReadFieldMaybe(parent, attr.name, attr.value);
 2820    }ind_end;
 2821    return retval;
 2822}
 2823
 2824// --- fasttest.GroupTrvOpt..Print
 2825// print string representation of ROW to string STR
 2826// cfmt:fasttest.GroupTrvOpt.String  printfmt:Tuple
 2827void fasttest::GroupTrvOpt_Print(fasttest::GroupTrvOpt& row, algo::cstring& str) {
 2828    algo::tempstr temp;
 2829    str << "fasttest.GroupTrvOpt";
 2830
 2831    if (OptTrvGrp_PresentQ(row)) {
 2832        fasttest::OptTrvGrp_Print(row.OptTrvGrp, temp);
 2833        PrintAttrSpaceReset(str,"OptTrvGrp", temp);
 2834    }
 2835}
 2836
 2837// --- fasttest.GroupTrvOpt..FastEncode
 2838void fasttest::GroupTrvOpt_FastEncode(algo::ByteAry& buf, FastState& state, fasttest::GroupTrvOpt& parent) {
 2839    int index = ary_N(buf);
 2840    u64 pmap(0);
 2841    if (!tid_AssignedQ(state) || parent.id != state.tid) {
 2842        lib_fast::EncodeUnsigned(buf,parent.id,false);
 2843        lib_fast::SetPmapBit(pmap,0);
 2844    }
 2845    tid_SetAssigned(state);
 2846    state.tid = parent.id;
 2847    // OptTrvGrp group none optional
 2848    if (OptTrvGrp_PresentQ(parent)) {
 2849        OptTrvGrp_FastEncode(buf,state,parent.OptTrvGrp);
 2850        lib_fast::SetPmapBit(pmap,1);
 2851    }
 2852    lib_fast::InsertPmap(buf,index,pmap);
 2853}
 2854
 2855// --- fasttest.GroupTrvOpt..FastDecode
 2856bool fasttest::GroupTrvOpt_FastDecode(algo::memptr& from, u64 pmap, FastState& state, fasttest::GroupTrvOpt& parent) {
 2857    bool ok = true;
 2858    // OptTrvGrp group none optional
 2859    if (ok) {
 2860        bool prs = lib_fast::GetPmapBit(pmap,1);
 2861        pmask_qSetBitVal(parent,OptTrvGrp_Present_GetBit(parent),prs);
 2862        if (prs) {
 2863            ok = OptTrvGrp_FastDecode(from,state,parent.OptTrvGrp);
 2864        }
 2865    }
 2866    return ok;
 2867}
 2868
 2869// --- fasttest.GroupTrvOpt..FixEncode
 2870void fasttest::GroupTrvOpt_FixEncode(cstring& buf, fasttest::GroupTrvOpt& parent, char soh) {
 2871    if (OptTrvGrp_PresentQ(parent)) {
 2872        OptTrvGrp_FixEncode(buf,parent.OptTrvGrp,soh);
 2873    }
 2874}
 2875
 2876// --- fasttest.I32Const.base.CopyOut
 2877// Copy fields out of row
 2878void fasttest::parent_CopyOut(fasttest::I32Const &row, fasttest::TemplateHeader &out) {
 2879    // length: field value is computed
 2880    // id: field value is computed
 2881    (void)row;//only to avoid -Wunused-parameter
 2882    (void)out;//only to avoid -Wunused-parameter
 2883}
 2884
 2885// --- fasttest.I32Const..ReadFieldMaybe
 2886bool fasttest::I32Const_ReadFieldMaybe(fasttest::I32Const& parent, algo::strptr field, algo::strptr strval) {
 2887    bool retval = true;
 2888    fasttest::FieldId field_id;
 2889    (void)value_SetStrptrMaybe(field_id,field);
 2890    switch(field_id) {
 2891        case fasttest_FieldId_base: {
 2892            retval = false;
 2893            break;
 2894        }
 2895        case fasttest_FieldId_length: {
 2896            retval = false;
 2897            break;
 2898        }
 2899        case fasttest_FieldId_id: {
 2900            retval = false;
 2901            break;
 2902        }
 2903        case fasttest_FieldId_Value: {
 2904            retval = true;
 2905            break;
 2906        }
 2907        default: break;
 2908    }
 2909    if (!retval) {
 2910        algo_lib::AppendErrtext("attr",field);
 2911    }
 2912    (void)parent;//only to avoid -Wunused-parameter
 2913    (void)strval;//only to avoid -Wunused-parameter
 2914    return retval;
 2915}
 2916
 2917// --- fasttest.I32Const..ReadStrptrMaybe
 2918// Read fields of fasttest::I32Const from an ascii string.
 2919// The format of the string is an ssim Tuple
 2920bool fasttest::I32Const_ReadStrptrMaybe(fasttest::I32Const &parent, algo::strptr in_str) {
 2921    bool retval = true;
 2922    retval = algo::StripTypeTag(in_str, "fasttest.I32Const");
 2923    ind_beg(algo::Attr_curs, attr, in_str) {
 2924        retval = retval && I32Const_ReadFieldMaybe(parent, attr.name, attr.value);
 2925    }ind_end;
 2926    return retval;
 2927}
 2928
 2929// --- fasttest.I32Const..Print
 2930// print string representation of ROW to string STR
 2931// cfmt:fasttest.I32Const.String  printfmt:Tuple
 2932void fasttest::I32Const_Print(fasttest::I32Const& row, algo::cstring& str) {
 2933    algo::tempstr temp;
 2934    str << "fasttest.I32Const";
 2935
 2936    i32_Print(Value_Get(row), temp);
 2937    PrintAttrSpaceReset(str,"Value", temp);
 2938}
 2939
 2940// --- fasttest.I32Const..FastEncode
 2941void fasttest::I32Const_FastEncode(algo::ByteAry& buf, FastState& state, fasttest::I32Const& parent) {
 2942    int index = ary_N(buf);
 2943    u64 pmap(0);
 2944    if (!tid_AssignedQ(state) || parent.id != state.tid) {
 2945        lib_fast::EncodeUnsigned(buf,parent.id,false);
 2946        lib_fast::SetPmapBit(pmap,0);
 2947    }
 2948    tid_SetAssigned(state);
 2949    state.tid = parent.id;
 2950    // Value signed constant mandatory
 2951    lib_fast::InsertPmap(buf,index,pmap);
 2952}
 2953
 2954// --- fasttest.I32Const..FastDecode
 2955bool fasttest::I32Const_FastDecode(algo::memptr& from, u64 pmap, FastState& state, fasttest::I32Const& parent) {
 2956    bool ok = true;
 2957    // Value signed constant mandatory
 2958    if (ok) {
 2959    }
 2960    (void)from;//only to avoid -Wunused-parameter
 2961    (void)pmap;//only to avoid -Wunused-parameter
 2962    (void)state;//only to avoid -Wunused-parameter
 2963    (void)parent;//only to avoid -Wunused-parameter
 2964    return ok;
 2965}
 2966
 2967// --- fasttest.I32Const..FixEncode
 2968void fasttest::I32Const_FixEncode(cstring& buf, fasttest::I32Const& parent, char soh) {
 2969    buf << "1=" << Value_Get(parent) << soh;
 2970}
 2971
 2972// --- fasttest.I32ConstOpt.base.CopyOut
 2973// Copy fields out of row
 2974void fasttest::parent_CopyOut(fasttest::I32ConstOpt &row, fasttest::TemplateHeader &out) {
 2975    // length: field value is computed
 2976    // id: field value is computed
 2977    (void)row;//only to avoid -Wunused-parameter
 2978    (void)out;//only to avoid -Wunused-parameter
 2979}
 2980
 2981// --- fasttest.I32ConstOpt.pmask_bitcurs.Next
 2982// proceed to next item
 2983void fasttest::I32ConstOpt_pmask_bitcurs_Next(I32ConstOpt_pmask_bitcurs &curs) {
 2984    ++curs.bit;
 2985    int index = curs.bit / 32;
 2986    int offset = curs.bit % 32;
 2987    for (; index < curs.n_elems; ++index, offset = 0) {
 2988        u64 rest = curs.elems[index] >> offset;
 2989        if (rest) {
 2990            offset += algo::u64_BitScanForward(rest);
 2991            break;
 2992        }
 2993    }
 2994    curs.bit = index * 32 + offset;
 2995}
 2996
 2997// --- fasttest.I32ConstOpt..ReadFieldMaybe
 2998bool fasttest::I32ConstOpt_ReadFieldMaybe(fasttest::I32ConstOpt& parent, algo::strptr field, algo::strptr strval) {
 2999    bool retval = true;
 3000    fasttest::FieldId field_id;
 3001    (void)value_SetStrptrMaybe(field_id,field);
 3002    switch(field_id) {
 3003        case fasttest_FieldId_base: {
 3004            retval = false;
 3005            break;
 3006        }
 3007        case fasttest_FieldId_length: {
 3008            retval = false;
 3009            break;
 3010        }
 3011        case fasttest_FieldId_id: {
 3012            retval = false;
 3013            break;
 3014        }
 3015        case fasttest_FieldId_pmask: {
 3016            retval = false;
 3017            break;
 3018        }
 3019        case fasttest_FieldId_Value: {
 3020            retval = true;
 3021            if (retval) {
 3022                pmask_qSetBit(parent, 0);
 3023            }
 3024            break;
 3025        }
 3026        default: break;
 3027    }
 3028    if (!retval) {
 3029        algo_lib::AppendErrtext("attr",field);
 3030    }
 3031    (void)strval;//only to avoid -Wunused-parameter
 3032    return retval;
 3033}
 3034
 3035// --- fasttest.I32ConstOpt..ReadStrptrMaybe
 3036// Read fields of fasttest::I32ConstOpt from an ascii string.
 3037// The format of the string is an ssim Tuple
 3038bool fasttest::I32ConstOpt_ReadStrptrMaybe(fasttest::I32ConstOpt &parent, algo::strptr in_str) {
 3039    bool retval = true;
 3040    retval = algo::StripTypeTag(in_str, "fasttest.I32ConstOpt");
 3041    ind_beg(algo::Attr_curs, attr, in_str) {
 3042        retval = retval && I32ConstOpt_ReadFieldMaybe(parent, attr.name, attr.value);
 3043    }ind_end;
 3044    return retval;
 3045}
 3046
 3047// --- fasttest.I32ConstOpt..Print
 3048// print string representation of ROW to string STR
 3049// cfmt:fasttest.I32ConstOpt.String  printfmt:Tuple
 3050void fasttest::I32ConstOpt_Print(fasttest::I32ConstOpt& row, algo::cstring& str) {
 3051    algo::tempstr temp;
 3052    str << "fasttest.I32ConstOpt";
 3053
 3054    if (Value_PresentQ(row)) {
 3055        i32_Print(Value_Get(row), temp);
 3056        PrintAttrSpaceReset(str,"Value", temp);
 3057    }
 3058}
 3059
 3060// --- fasttest.I32ConstOpt..FastEncode
 3061void fasttest::I32ConstOpt_FastEncode(algo::ByteAry& buf, FastState& state, fasttest::I32ConstOpt& parent) {
 3062    int index = ary_N(buf);
 3063    u64 pmap(0);
 3064    if (!tid_AssignedQ(state) || parent.id != state.tid) {
 3065        lib_fast::EncodeUnsigned(buf,parent.id,false);
 3066        lib_fast::SetPmapBit(pmap,0);
 3067    }
 3068    tid_SetAssigned(state);
 3069    state.tid = parent.id;
 3070    // Value signed constant optional
 3071    if (Value_PresentQ(parent)) {
 3072        lib_fast::SetPmapBit(pmap,1);
 3073    }
 3074    lib_fast::InsertPmap(buf,index,pmap);
 3075}
 3076
 3077// --- fasttest.I32ConstOpt..FastDecode
 3078bool fasttest::I32ConstOpt_FastDecode(algo::memptr& from, u64 pmap, FastState& state, fasttest::I32ConstOpt& parent) {
 3079    bool ok = true;
 3080    // Value signed constant optional
 3081    if (ok) {
 3082        bool prs = lib_fast::GetPmapBit(pmap,1);
 3083        pmask_qSetBitVal(parent,Value_Present_GetBit(parent),prs);
 3084    }
 3085    (void)from;//only to avoid -Wunused-parameter
 3086    (void)state;//only to avoid -Wunused-parameter
 3087    return ok;
 3088}
 3089
 3090// --- fasttest.I32ConstOpt..FixEncode
 3091void fasttest::I32ConstOpt_FixEncode(cstring& buf, fasttest::I32ConstOpt& parent, char soh) {
 3092    if (Value_PresentQ(parent)) {
 3093        buf << "1=" << Value_Get(parent) << soh;
 3094    }
 3095}
 3096
 3097// --- fasttest.I32Copy.base.CopyOut
 3098// Copy fields out of row
 3099void fasttest::parent_CopyOut(fasttest::I32Copy &row, fasttest::TemplateHeader &out) {
 3100    // length: field value is computed
 3101    // id: field value is computed
 3102    (void)row;//only to avoid -Wunused-parameter
 3103    (void)out;//only to avoid -Wunused-parameter
 3104}
 3105
 3106// --- fasttest.I32Copy..ReadFieldMaybe
 3107bool fasttest::I32Copy_ReadFieldMaybe(fasttest::I32Copy& parent, algo::strptr field, algo::strptr strval) {
 3108    bool retval = true;
 3109    fasttest::FieldId field_id;
 3110    (void)value_SetStrptrMaybe(field_id,field);
 3111    switch(field_id) {
 3112        case fasttest_FieldId_base: {
 3113            retval = false;
 3114            break;
 3115        }
 3116        case fasttest_FieldId_length: {
 3117            retval = false;
 3118            break;
 3119        }
 3120        case fasttest_FieldId_id: {
 3121            retval = false;
 3122            break;
 3123        }
 3124        case fasttest_FieldId_Value49: {
 3125            retval = i32_ReadStrptrMaybe(parent.Value49, strval);
 3126            break;
 3127        }
 3128        default: break;
 3129    }
 3130    if (!retval) {
 3131        algo_lib::AppendErrtext("attr",field);
 3132    }
 3133    return retval;
 3134}
 3135
 3136// --- fasttest.I32Copy..ReadStrptrMaybe
 3137// Read fields of fasttest::I32Copy from an ascii string.
 3138// The format of the string is an ssim Tuple
 3139bool fasttest::I32Copy_ReadStrptrMaybe(fasttest::I32Copy &parent, algo::strptr in_str) {
 3140    bool retval = true;
 3141    retval = algo::StripTypeTag(in_str, "fasttest.I32Copy");
 3142    ind_beg(algo::Attr_curs, attr, in_str) {
 3143        retval = retval && I32Copy_ReadFieldMaybe(parent, attr.name, attr.value);
 3144    }ind_end;
 3145    return retval;
 3146}
 3147
 3148// --- fasttest.I32Copy..Print
 3149// print string representation of ROW to string STR
 3150// cfmt:fasttest.I32Copy.String  printfmt:Tuple
 3151void fasttest::I32Copy_Print(fasttest::I32Copy& row, algo::cstring& str) {
 3152    algo::tempstr temp;
 3153    str << "fasttest.I32Copy";
 3154
 3155    i32_Print(row.Value49, temp);
 3156    PrintAttrSpaceReset(str,"Value49", temp);
 3157}
 3158
 3159// --- fasttest.I32Copy..FastEncode
 3160void fasttest::I32Copy_FastEncode(algo::ByteAry& buf, FastState& state, fasttest::I32Copy& parent) {
 3161    int index = ary_N(buf);
 3162    u64 pmap(0);
 3163    if (!tid_AssignedQ(state) || parent.id != state.tid) {
 3164        lib_fast::EncodeUnsigned(buf,parent.id,false);
 3165        lib_fast::SetPmapBit(pmap,0);
 3166    }
 3167    tid_SetAssigned(state);
 3168    state.tid = parent.id;
 3169    // Value49 signed copy mandatory
 3170    if (Value49_AssignedQ(state) ? parent.Value49 != state.Value49 : parent.Value49 != 49) {
 3171        lib_fast::EncodeSigned(buf,parent.Value49,false);
 3172        lib_fast::SetPmapBit(pmap,1);
 3173    }
 3174    state.Value49 = parent.Value49;
 3175    Value49_SetAssigned(state);
 3176    lib_fast::InsertPmap(buf,index,pmap);
 3177}
 3178
 3179// --- fasttest.I32Copy..FastDecode
 3180bool fasttest::I32Copy_FastDecode(algo::memptr& from, u64 pmap, FastState& state, fasttest::I32Copy& parent) {
 3181    bool ok = true;
 3182    // Value49 signed copy mandatory
 3183    if (ok) {
 3184        bool prs = lib_fast::GetPmapBit(pmap,1);
 3185        if (prs) {
 3186            ok = lib_fast::DecodeSigned(from,parent.Value49,false);
 3187            if (!ok) {
 3188                state.error << "fasttest.I32Copy.Value49: bad Signed" << eol;
 3189            }
 3190        } else if (Value49_AssignedQ(state)) {
 3191            parent.Value49 = state.Value49;
 3192        } else {
 3193            parent.Value49 = 49;
 3194        }
 3195        Value49_SetAssigned(state);
 3196        state.Value49 = parent.Value49;
 3197    }
 3198    return ok;
 3199}
 3200
 3201// --- fasttest.I32Copy..FixEncode
 3202void fasttest::I32Copy_FixEncode(cstring& buf, fasttest::I32Copy& parent, char soh) {
 3203    buf << "1=" << parent.Value49 << soh;
 3204}
 3205
 3206// --- fasttest.I32CopyNull.base.CopyOut
 3207// Copy fields out of row
 3208void fasttest::parent_CopyOut(fasttest::I32CopyNull &row, fasttest::TemplateHeader &out) {
 3209    // length: field value is computed
 3210    // id: field value is computed
 3211    (void)row;//only to avoid -Wunused-parameter
 3212    (void)out;//only to avoid -Wunused-parameter
 3213}
 3214
 3215// --- fasttest.I32CopyNull.Value51.ReadStrptrMaybe
 3216inline static bool fasttest::Value51_ReadStrptrMaybe(fasttest::I32CopyNull &parent, algo::strptr in_str) {
 3217    bool retval = true;
 3218    i32 Value51_tmp;
 3219    retval = i32_ReadStrptrMaybe(Value51_tmp, in_str);
 3220    if (retval) {
 3221        Value51_Set(parent, Value51_tmp);
 3222    }
 3223    return retval;
 3224}
 3225
 3226// --- fasttest.I32CopyNull.pmask_bitcurs.Next
 3227// proceed to next item
 3228void fasttest::I32CopyNull_pmask_bitcurs_Next(I32CopyNull_pmask_bitcurs &curs) {
 3229    ++curs.bit;
 3230    int index = curs.bit / 32;
 3231    int offset = curs.bit % 32;
 3232    for (; index < curs.n_elems; ++index, offset = 0) {
 3233        u64 rest = curs.elems[index] >> offset;
 3234        if (rest) {
 3235            offset += algo::u64_BitScanForward(rest);
 3236            break;
 3237        }
 3238    }
 3239    curs.bit = index * 32 + offset;
 3240}
 3241
 3242// --- fasttest.I32CopyNull..ReadFieldMaybe
 3243bool fasttest::I32CopyNull_ReadFieldMaybe(fasttest::I32CopyNull& parent, algo::strptr field, algo::strptr strval) {
 3244    bool retval = true;
 3245    fasttest::FieldId field_id;
 3246    (void)value_SetStrptrMaybe(field_id,field);
 3247    switch(field_id) {
 3248        case fasttest_FieldId_base: {
 3249            retval = false;
 3250            break;
 3251        }
 3252        case fasttest_FieldId_length: {
 3253            retval = false;
 3254            break;
 3255        }
 3256        case fasttest_FieldId_id: {
 3257            retval = false;
 3258            break;
 3259        }
 3260        case fasttest_FieldId_pmask: {
 3261            retval = false;
 3262            break;
 3263        }
 3264        case fasttest_FieldId_Value51: {
 3265            retval = Value51_ReadStrptrMaybe(parent, strval);
 3266            if (retval) {
 3267                pmask_qSetBit(parent, 0);
 3268            }
 3269            break;
 3270        }
 3271        default: break;
 3272    }
 3273    if (!retval) {
 3274        algo_lib::AppendErrtext("attr",field);
 3275    }
 3276    return retval;
 3277}
 3278
 3279// --- fasttest.I32CopyNull..ReadStrptrMaybe
 3280// Read fields of fasttest::I32CopyNull from an ascii string.
 3281// The format of the string is an ssim Tuple
 3282bool fasttest::I32CopyNull_ReadStrptrMaybe(fasttest::I32CopyNull &parent, algo::strptr in_str) {
 3283    bool retval = true;
 3284    retval = algo::StripTypeTag(in_str, "fasttest.I32CopyNull");
 3285    ind_beg(algo::Attr_curs, attr, in_str) {
 3286        retval = retval && I32CopyNull_ReadFieldMaybe(parent, attr.name, attr.value);
 3287    }ind_end;
 3288    return retval;
 3289}
 3290
 3291// --- fasttest.I32CopyNull..Print
 3292// print string representation of ROW to string STR
 3293// cfmt:fasttest.I32CopyNull.String  printfmt:Tuple
 3294void fasttest::I32CopyNull_Print(fasttest::I32CopyNull& row, algo::cstring& str) {
 3295    algo::tempstr temp;
 3296    str << "fasttest.I32CopyNull";
 3297
 3298    if (Value51_PresentQ(row)) {
 3299        i32_Print(row.Value51, temp);
 3300        PrintAttrSpaceReset(str,"Value51", temp);
 3301    }
 3302}
 3303
 3304// --- fasttest.I32CopyNull..FastEncode
 3305void fasttest::I32CopyNull_FastEncode(algo::ByteAry& buf, FastState& state, fasttest::I32CopyNull& parent) {
 3306    int index = ary_N(buf);
 3307    u64 pmap(0);
 3308    if (!tid_AssignedQ(state) || parent.id != state.tid) {
 3309        lib_fast::EncodeUnsigned(buf,parent.id,false);
 3310        lib_fast::SetPmapBit(pmap,0);
 3311    }
 3312    tid_SetAssigned(state);
 3313    state.tid = parent.id;
 3314    // Value51 signed copy optional
 3315    if (Value51_PresentQ(parent)) {
 3316        if (!Value51_AssignedQ(state) || !Value51_PresentQ(state) ||  parent.Value51 != state.Value51 ) {
 3317            lib_fast::EncodeSigned(buf,parent.Value51,true);
 3318            lib_fast::SetPmapBit(pmap,1);
 3319        }
 3320    } else {
 3321        if (Value51_AssignedQ(state)) {
 3322            lib_fast::EncodeNull(buf);
 3323            lib_fast::SetPmapBit(pmap,1);
 3324        }
 3325    }
 3326    state.Value51 = parent.Value51;
 3327    present_qSetBitVal(state,Value51_Present_GetBit(state),Value51_PresentQ(parent));
 3328    Value51_SetAssigned(state);
 3329    lib_fast::InsertPmap(buf,index,pmap);
 3330}
 3331
 3332// --- fasttest.I32CopyNull..FastDecode
 3333bool fasttest::I32CopyNull_FastDecode(algo::memptr& from, u64 pmap, FastState& state, fasttest::I32CopyNull& parent) {
 3334    bool ok = true;
 3335    // Value51 signed copy optional
 3336    if (ok) {
 3337        bool prs = lib_fast::GetPmapBit(pmap,1);
 3338        if (prs) {
 3339            prs = !lib_fast::DecodeNull(from);
 3340            if (prs) {
 3341                ok = lib_fast::DecodeSigned(from,parent.Value51,true);
 3342                if (!ok) {
 3343                    state.error << "fasttest.I32CopyNull.Value51: bad Signed" << eol;
 3344                }
 3345            }
 3346        } else if (Value51_AssignedQ(state)) {
 3347            parent.Value51 = state.Value51;
 3348            prs = Value51_PresentQ(state);
 3349        } else {
 3350            prs = false;
 3351        }
 3352        pmask_qSetBitVal(parent,Value51_Present_GetBit(parent),prs);
 3353        Value51_SetAssigned(state);
 3354        present_qSetBitVal(state,Value51_Present_GetBit(state),prs);
 3355        state.Value51 = parent.Value51;
 3356    }
 3357    return ok;
 3358}
 3359
 3360// --- fasttest.I32CopyNull..FixEncode
 3361void fasttest::I32CopyNull_FixEncode(cstring& buf, fasttest::I32CopyNull& parent, char soh) {
 3362    if (Value51_PresentQ(parent)) {
 3363        buf << "1=" << parent.Value51 << soh;
 3364    }
 3365}
 3366
 3367// --- fasttest.I32CopyOpt.base.CopyOut
 3368// Copy fields out of row
 3369void fasttest::parent_CopyOut(fasttest::I32CopyOpt &row, fasttest::TemplateHeader &out) {
 3370    // length: field value is computed
 3371    // id: field value is computed
 3372    (void)row;//only to avoid -Wunused-parameter
 3373    (void)out;//only to avoid -Wunused-parameter
 3374}
 3375
 3376// --- fasttest.I32CopyOpt.Value50.ReadStrptrMaybe
 3377inline static bool fasttest::Value50_ReadStrptrMaybe(fasttest::I32CopyOpt &parent, algo::strptr in_str) {
 3378    bool retval = true;
 3379    i32 Value50_tmp;
 3380    retval = i32_ReadStrptrMaybe(Value50_tmp, in_str);
 3381    if (retval) {
 3382        Value50_Set(parent, Value50_tmp);
 3383    }
 3384    return retval;
 3385}
 3386
 3387// --- fasttest.I32CopyOpt.pmask_bitcurs.Next
 3388// proceed to next item
 3389void fasttest::I32CopyOpt_pmask_bitcurs_Next(I32CopyOpt_pmask_bitcurs &curs) {
 3390    ++curs.bit;
 3391    int index = curs.bit / 32;
 3392    int offset = curs.bit % 32;
 3393    for (; index < curs.n_elems; ++index, offset = 0) {
 3394        u64 rest = curs.elems[index] >> offset;
 3395        if (rest) {
 3396            offset += algo::u64_BitScanForward(rest);
 3397            break;
 3398        }
 3399    }
 3400    curs.bit = index * 32 + offset;
 3401}
 3402
 3403// --- fasttest.I32CopyOpt..ReadFieldMaybe
 3404bool fasttest::I32CopyOpt_ReadFieldMaybe(fasttest::I32CopyOpt& parent, algo::strptr field, algo::strptr strval) {
 3405    bool retval = true;
 3406    fasttest::FieldId field_id;
 3407    (void)value_SetStrptrMaybe(field_id,field);
 3408    switch(field_id) {
 3409        case fasttest_FieldId_base: {
 3410            retval = false;
 3411            break;
 3412        }
 3413        case fasttest_FieldId_length: {
 3414            retval = false;
 3415            break;
 3416        }
 3417        case fasttest_FieldId_id: {
 3418            retval = false;
 3419            break;
 3420        }
 3421        case fasttest_FieldId_pmask: {
 3422            retval = false;
 3423            break;
 3424        }
 3425        case fasttest_FieldId_Value50: {
 3426            retval = Value50_ReadStrptrMaybe(parent, strval);
 3427            if (retval) {
 3428                pmask_qSetBit(parent, 0);
 3429            }
 3430            break;
 3431        }
 3432        default: break;
 3433    }
 3434    if (!retval) {
 3435        algo_lib::AppendErrtext("attr",field);
 3436    }
 3437    return retval;
 3438}
 3439
 3440// --- fasttest.I32CopyOpt..ReadStrptrMaybe
 3441// Read fields of fasttest::I32CopyOpt from an ascii string.
 3442// The format of the string is an ssim Tuple
 3443bool fasttest::I32CopyOpt_ReadStrptrMaybe(fasttest::I32CopyOpt &parent, algo::strptr in_str) {
 3444    bool retval = true;
 3445    retval = algo::StripTypeTag(in_str, "fasttest.I32CopyOpt");
 3446    ind_beg(algo::Attr_curs, attr, in_str) {
 3447        retval = retval && I32CopyOpt_ReadFieldMaybe(parent, attr.name, attr.value);
 3448    }ind_end;
 3449    return retval;
 3450}
 3451
 3452// --- fasttest.I32CopyOpt..Print
 3453// print string representation of ROW to string STR
 3454// cfmt:fasttest.I32CopyOpt.String  printfmt:Tuple
 3455void fasttest::I32CopyOpt_Print(fasttest::I32CopyOpt& row, algo::cstring& str) {
 3456    algo::tempstr temp;
 3457    str << "fasttest.I32CopyOpt";
 3458
 3459    if (Value50_PresentQ(row)) {
 3460        i32_Print(row.Value50, temp);
 3461        PrintAttrSpaceReset(str,"Value50", temp);
 3462    }
 3463}
 3464
 3465// --- fasttest.I32CopyOpt..FastEncode
 3466void fasttest::I32CopyOpt_FastEncode(algo::ByteAry& buf, FastState& state, fasttest::I32CopyOpt& parent) {
 3467    int index = ary_N(buf);
 3468    u64 pmap(0);
 3469    if (!tid_AssignedQ(state) || parent.id != state.tid) {
 3470        lib_fast::EncodeUnsigned(buf,parent.id,false);
 3471        lib_fast::SetPmapBit(pmap,0);
 3472    }
 3473    tid_SetAssigned(state);
 3474    state.tid = parent.id;
 3475    // Value50 signed copy optional
 3476    if (Value50_PresentQ(parent)) {
 3477        if (Value50_AssignedQ(state) ? !Value50_PresentQ(state) || parent.Value50 != state.Value50 : parent.Value50 != 50) {
 3478            lib_fast::EncodeSigned(buf,parent.Value50,true);
 3479            lib_fast::SetPmapBit(pmap,1);
 3480        }
 3481    } else {
 3482        if (Value50_AssignedQ(state) && Value50_PresentQ(state)) {
 3483            lib_fast::EncodeNull(buf);
 3484            lib_fast::SetPmapBit(pmap,1);
 3485        }
 3486    }
 3487    state.Value50 = parent.Value50;
 3488    present_qSetBitVal(state,Value50_Present_GetBit(state),Value50_PresentQ(parent));
 3489    Value50_SetAssigned(state);
 3490    lib_fast::InsertPmap(buf,index,pmap);
 3491}
 3492
 3493// --- fasttest.I32CopyOpt..FastDecode
 3494bool fasttest::I32CopyOpt_FastDecode(algo::memptr& from, u64 pmap, FastState& state, fasttest::I32CopyOpt& parent) {
 3495    bool ok = true;
 3496    // Value50 signed copy optional
 3497    if (ok) {
 3498        bool prs = lib_fast::GetPmapBit(pmap,1);
 3499        if (prs) {
 3500            prs = !lib_fast::DecodeNull(from);
 3501            if (prs) {
 3502                ok = lib_fast::DecodeSigned(from,parent.Value50,true);
 3503                if (!ok) {
 3504                    state.error << "fasttest.I32CopyOpt.Value50: bad Signed" << eol;
 3505                }
 3506            }
 3507        } else if (Value50_AssignedQ(state)) {
 3508            parent.Value50 = state.Value50;
 3509            prs = Value50_PresentQ(state);
 3510        } else {
 3511            parent.Value50 = 50;
 3512            prs = true;
 3513        }
 3514        pmask_qSetBitVal(parent,Value50_Present_GetBit(parent),prs);
 3515        Value50_SetAssigned(state);
 3516        present_qSetBitVal(state,Value50_Present_GetBit(state),prs);
 3517        state.Value50 = parent.Value50;
 3518    }
 3519    return ok;
 3520}
 3521
 3522// --- fasttest.I32CopyOpt..FixEncode
 3523void fasttest::I32CopyOpt_FixEncode(cstring& buf, fasttest::I32CopyOpt& parent, char soh) {
 3524    if (Value50_PresentQ(parent)) {
 3525        buf << "1=" << parent.Value50 << soh;
 3526    }
 3527}
 3528
 3529// --- fasttest.I32Delta.base.CopyOut
 3530// Copy fields out of row
 3531void fasttest::parent_CopyOut(fasttest::I32Delta &row, fasttest::TemplateHeader &out) {
 3532    // length: field value is computed
 3533    // id: field value is computed
 3534    (void)row;//only to avoid -Wunused-parameter
 3535    (void)out;//only to avoid -Wunused-parameter
 3536}
 3537
 3538// --- fasttest.I32Delta..ReadFieldMaybe
 3539bool fasttest::I32Delta_ReadFieldMaybe(fasttest::I32Delta& parent, algo::strptr field, algo::strptr strval) {
 3540    bool retval = true;
 3541    fasttest::FieldId field_id;
 3542    (void)value_SetStrptrMaybe(field_id,field);
 3543    switch(field_id) {
 3544        case fasttest_FieldId_base: {
 3545            retval = false;
 3546            break;
 3547        }
 3548        case fasttest_FieldId_length: {
 3549            retval = false;
 3550            break;
 3551        }
 3552        case fasttest_FieldId_id: {
 3553            retval = false;
 3554            break;
 3555        }
 3556        case fasttest_FieldId_Value65: {
 3557            retval = i32_ReadStrptrMaybe(parent.Value65, strval);
 3558            break;
 3559        }
 3560        default: break;
 3561    }
 3562    if (!retval) {
 3563        algo_lib::AppendErrtext("attr",field);
 3564    }
 3565    return retval;
 3566}
 3567
 3568// --- fasttest.I32Delta..ReadStrptrMaybe
 3569// Read fields of fasttest::I32Delta from an ascii string.
 3570// The format of the string is an ssim Tuple
 3571bool fasttest::I32Delta_ReadStrptrMaybe(fasttest::I32Delta &parent, algo::strptr in_str) {
 3572    bool retval = true;
 3573    retval = algo::StripTypeTag(in_str, "fasttest.I32Delta");
 3574    ind_beg(algo::Attr_curs, attr, in_str) {
 3575        retval = retval && I32Delta_ReadFieldMaybe(parent, attr.name, attr.value);
 3576    }ind_end;
 3577    return retval;
 3578}
 3579
 3580// --- fasttest.I32Delta..Print
 3581// print string representation of ROW to string STR
 3582// cfmt:fasttest.I32Delta.String  printfmt:Tuple
 3583void fasttest::I32Delta_Print(fasttest::I32Delta& row, algo::cstring& str) {
 3584    algo::tempstr temp;
 3585    str << "fasttest.I32Delta";
 3586
 3587    i32_Print(row.Value65, temp);
 3588    PrintAttrSpaceReset(str,"Value65", temp);
 3589}
 3590
 3591// --- fasttest.I32Delta..FastEncode
 3592void fasttest::I32Delta_FastEncode(algo::ByteAry& buf, FastState& state, fasttest::I32Delta& parent) {
 3593    int index = ary_N(buf);
 3594    u64 pmap(0);
 3595    if (!tid_AssignedQ(state) || parent.id != state.tid) {
 3596        lib_fast::EncodeUnsigned(buf,parent.id,false);
 3597        lib_fast::SetPmapBit(pmap,0);
 3598    }
 3599    tid_SetAssigned(state);
 3600    state.tid = parent.id;
 3601    // Value65 signed delta mandatory
 3602    if (!Value65_AssignedQ(state)) {
 3603        Value65_SetAssigned(state);
 3604        state.Value65 = 65;
 3605    }
 3606    lib_fast::EncodeDeltaSigned(buf,state.Value65,parent.Value65,false);
 3607    state.Value65 = parent.Value65;
 3608    lib_fast::InsertPmap(buf,index,pmap);
 3609}
 3610
 3611// --- fasttest.I32Delta..FastDecode
 3612bool fasttest::I32Delta_FastDecode(algo::memptr& from, u64 pmap, FastState& state, fasttest::I32Delta& parent) {
 3613    bool ok = true;
 3614    // Value65 signed delta mandatory
 3615    if (ok) {
 3616        if (!Value65_AssignedQ(state)) {
 3617            Value65_SetAssigned(state);
 3618            state.Value65 = 65;
 3619        }
 3620        ok = lib_fast::DecodeDeltaSigned(from,state.Value65,parent.Value65,false);
 3621        if (!ok) {
 3622            state.error << "fasttest.I32Delta.Value65: bad Signed delta" << eol;
 3623        }
 3624        state.Value65 = parent.Value65;
 3625    }
 3626    (void)pmap;//only to avoid -Wunused-parameter
 3627    return ok;
 3628}
 3629
 3630// --- fasttest.I32Delta..FixEncode
 3631void fasttest::I32Delta_FixEncode(cstring& buf, fasttest::I32Delta& parent, char soh) {
 3632    buf << "1=" << parent.Value65 << soh;
 3633}
 3634
 3635// --- fasttest.I32DeltaImpl.base.CopyOut
 3636// Copy fields out of row
 3637void fasttest::parent_CopyOut(fasttest::I32DeltaImpl &row, fasttest::TemplateHeader &out) {
 3638    // length: field value is computed
 3639    // id: field value is computed
 3640    (void)row;//only to avoid -Wunused-parameter
 3641    (void)out;//only to avoid -Wunused-parameter
 3642}
 3643
 3644// --- fasttest.I32DeltaImpl..ReadFieldMaybe
 3645bool fasttest::I32DeltaImpl_ReadFieldMaybe(fasttest::I32DeltaImpl& parent, algo::strptr field, algo::strptr strval) {
 3646    bool retval = true;
 3647    fasttest::FieldId field_id;
 3648    (void)value_SetStrptrMaybe(field_id,field);
 3649    switch(field_id) {
 3650        case fasttest_FieldId_base: {
 3651            retval = false;
 3652            break;
 3653        }
 3654        case fasttest_FieldId_length: {
 3655            retval = false;
 3656            break;
 3657        }
 3658        case fasttest_FieldId_id: {
 3659            retval = false;
 3660            break;
 3661        }
 3662        case fasttest_FieldId_Value66: {
 3663            retval = i32_ReadStrptrMaybe(parent.Value66, strval);
 3664            break;
 3665        }
 3666        default: break;
 3667    }
 3668    if (!retval) {
 3669        algo_lib::AppendErrtext("attr",field);
 3670    }
 3671    return retval;
 3672}
 3673
 3674// --- fasttest.I32DeltaImpl..ReadStrptrMaybe
 3675// Read fields of fasttest::I32DeltaImpl from an ascii string.
 3676// The format of the string is an ssim Tuple
 3677bool fasttest::I32DeltaImpl_ReadStrptrMaybe(fasttest::I32DeltaImpl &parent, algo::strptr in_str) {
 3678    bool retval = true;
 3679    retval = algo::StripTypeTag(in_str, "fasttest.I32DeltaImpl");
 3680    ind_beg(algo::Attr_curs, attr, in_str) {
 3681        retval = retval && I32DeltaImpl_ReadFieldMaybe(parent, attr.name, attr.value);
 3682    }ind_end;
 3683    return retval;
 3684}
 3685
 3686// --- fasttest.I32DeltaImpl..Print
 3687// print string representation of ROW to string STR
 3688// cfmt:fasttest.I32DeltaImpl.String  printfmt:Tuple
 3689void fasttest::I32DeltaImpl_Print(fasttest::I32DeltaImpl& row, algo::cstring& str) {
 3690    algo::tempstr temp;
 3691    str << "fasttest.I32DeltaImpl";
 3692
 3693    i32_Print(row.Value66, temp);
 3694    PrintAttrSpaceReset(str,"Value66", temp);
 3695}
 3696
 3697// --- fasttest.I32DeltaImpl..FastEncode
 3698void fasttest::I32DeltaImpl_FastEncode(algo::ByteAry& buf, FastState& state, fasttest::I32DeltaImpl& parent) {
 3699    int index = ary_N(buf);
 3700    u64 pmap(0);
 3701    if (!tid_AssignedQ(state) || parent.id != state.tid) {
 3702        lib_fast::EncodeUnsigned(buf,parent.id,false);
 3703        lib_fast::SetPmapBit(pmap,0);
 3704    }
 3705    tid_SetAssigned(state);
 3706    state.tid = parent.id;
 3707    // Value66 signed delta mandatory
 3708    if (!Value66_AssignedQ(state)) {
 3709        Value66_SetAssigned(state);
 3710        state.Value66 = 0;
 3711    }
 3712    lib_fast::EncodeDeltaSigned(buf,state.Value66,parent.Value66,false);
 3713    state.Value66 = parent.Value66;
 3714    lib_fast::InsertPmap(buf,index,pmap);
 3715}
 3716
 3717// --- fasttest.I32DeltaImpl..FastDecode
 3718bool fasttest::I32DeltaImpl_FastDecode(algo::memptr& from, u64 pmap, FastState& state, fasttest::I32DeltaImpl& parent) {
 3719    bool ok = true;
 3720    // Value66 signed delta mandatory
 3721    if (ok) {
 3722        if (!Value66_AssignedQ(state)) {
 3723            Value66_SetAssigned(state);
 3724            state.Value66 = 0;
 3725        }
 3726        ok = lib_fast::DecodeDeltaSigned(from,state.Value66,parent.Value66,false);
 3727        if (!ok) {
 3728            state.error << "fasttest.I32DeltaImpl.Value66: bad Signed delta" << eol;
 3729        }
 3730        state.Value66 = parent.Value66;
 3731    }
 3732    (void)pmap;//only to avoid -Wunused-parameter
 3733    return ok;
 3734}
 3735
 3736// --- fasttest.I32DeltaImpl..FixEncode
 3737void fasttest::I32DeltaImpl_FixEncode(cstring& buf, fasttest::I32DeltaImpl& parent, char soh) {
 3738    buf << "1=" << parent.Value66 << soh;
 3739}
 3740
 3741// --- fasttest.I32DeltaNull.base.CopyOut
 3742// Copy fields out of row
 3743void fasttest::parent_CopyOut(fasttest::I32DeltaNull &row, fasttest::TemplateHeader &out) {
 3744    // length: field value is computed
 3745    // id: field value is computed
 3746    (void)row;//only to avoid -Wunused-parameter
 3747    (void)out;//only to avoid -Wunused-parameter
 3748}
 3749
 3750// --- fasttest.I32DeltaNull.Value68.ReadStrptrMaybe
 3751inline static bool fasttest::Value68_ReadStrptrMaybe(fasttest::I32DeltaNull &parent, algo::strptr in_str) {
 3752    bool retval = true;
 3753    i32 Value68_tmp;
 3754    retval = i32_ReadStrptrMaybe(Value68_tmp, in_str);
 3755    if (retval) {
 3756        Value68_Set(parent, Value68_tmp);
 3757    }
 3758    return retval;
 3759}
 3760
 3761// --- fasttest.I32DeltaNull.pmask_bitcurs.Next
 3762// proceed to next item
 3763void fasttest::I32DeltaNull_pmask_bitcurs_Next(I32DeltaNull_pmask_bitcurs &curs) {
 3764    ++curs.bit;
 3765    int index = curs.bit / 32;
 3766    int offset = curs.bit % 32;
 3767    for (; index < curs.n_elems; ++index, offset = 0) {
 3768        u64 rest = curs.elems[index] >> offset;
 3769        if (rest) {
 3770            offset += algo::u64_BitScanForward(rest);
 3771            break;
 3772        }
 3773    }
 3774    curs.bit = index * 32 + offset;
 3775}
 3776
 3777// --- fasttest.I32DeltaNull..ReadFieldMaybe
 3778bool fasttest::I32DeltaNull_ReadFieldMaybe(fasttest::I32DeltaNull& parent, algo::strptr field, algo::strptr strval) {
 3779    bool retval = true;
 3780    fasttest::FieldId field_id;
 3781    (void)value_SetStrptrMaybe(field_id,field);
 3782    switch(field_id) {
 3783        case fasttest_FieldId_base: {
 3784            retval = false;
 3785            break;
 3786        }
 3787        case fasttest_FieldId_length: {
 3788            retval = false;
 3789            break;
 3790        }
 3791        case fasttest_FieldId_id: {
 3792            retval = false;
 3793            break;
 3794        }
 3795        case fasttest_FieldId_pmask: {
 3796            retval = false;
 3797            break;
 3798        }
 3799        case fasttest_FieldId_Value68: {
 3800            retval = Value68_ReadStrptrMaybe(parent, strval);
 3801            if (retval) {
 3802                pmask_qSetBit(parent, 0);
 3803            }
 3804            break;
 3805        }
 3806        default: break;
 3807    }
 3808    if (!retval) {
 3809        algo_lib::AppendErrtext("attr",field);
 3810    }
 3811    return retval;
 3812}
 3813
 3814// --- fasttest.I32DeltaNull..ReadStrptrMaybe
 3815// Read fields of fasttest::I32DeltaNull from an ascii string.
 3816// The format of the string is an ssim Tuple
 3817bool fasttest::I32DeltaNull_ReadStrptrMaybe(fasttest::I32DeltaNull &parent, algo::strptr in_str) {
 3818    bool retval = true;
 3819    retval = algo::StripTypeTag(in_str, "fasttest.I32DeltaNull");
 3820    ind_beg(algo::Attr_curs, attr, in_str) {
 3821        retval = retval && I32DeltaNull_ReadFieldMaybe(parent, attr.name, attr.value);
 3822    }ind_end;
 3823    return retval;
 3824}
 3825
 3826// --- fasttest.I32DeltaNull..Print
 3827// print string representation of ROW to string STR
 3828// cfmt:fasttest.I32DeltaNull.String  printfmt:Tuple
 3829void fasttest::I32DeltaNull_Print(fasttest::I32DeltaNull& row, algo::cstring& str) {
 3830    algo::tempstr temp;
 3831    str << "fasttest.I32DeltaNull";
 3832
 3833    if (Value68_PresentQ(row)) {
 3834        i32_Print(row.Value68, temp);
 3835        PrintAttrSpaceReset(str,"Value68", temp);
 3836    }
 3837}
 3838
 3839// --- fasttest.I32DeltaNull..FastEncode
 3840void fasttest::I32DeltaNull_FastEncode(algo::ByteAry& buf, FastState& state, fasttest::I32DeltaNull& parent) {
 3841    int index = ary_N(buf);
 3842    u64 pmap(0);
 3843    if (!tid_AssignedQ(state) || parent.id != state.tid) {
 3844        lib_fast::EncodeUnsigned(buf,parent.id,false);
 3845        lib_fast::SetPmapBit(pmap,0);
 3846    }
 3847    tid_SetAssigned(state);
 3848    state.tid = parent.id;
 3849    // Value68 signed delta optional
 3850    if (!Value68_AssignedQ(state)) {
 3851        Value68_SetAssigned(state);
 3852        present_qSetBitVal(state,Value68_Present_GetBit(state),Value68_PresentQ(parent));
 3853        state.Value68 = 0;
 3854    }
 3855    if (Value68_PresentQ(parent)) {
 3856        if (!Value68_PresentQ(state)) {
 3857            state.Value68 = 0;
 3858        }
 3859        lib_fast::EncodeDeltaSigned(buf,state.Value68,parent.Value68,true);
 3860    } else {
 3861        lib_fast::EncodeNull(buf);
 3862    }
 3863    state.Value68 = parent.Value68;
 3864    present_qSetBitVal(state,Value68_Present_GetBit(state),Value68_PresentQ(parent));
 3865    lib_fast::InsertPmap(buf,index,pmap);
 3866}
 3867
 3868// --- fasttest.I32DeltaNull..FastDecode
 3869bool fasttest::I32DeltaNull_FastDecode(algo::memptr& from, u64 pmap, FastState& state, fasttest::I32DeltaNull& parent) {
 3870    bool ok = true;
 3871    // Value68 signed delta optional
 3872    if (ok) {
 3873        if (!Value68_AssignedQ(state)) {
 3874            Value68_SetAssigned(state);
 3875            bool prs(true);
 3876            present_qSetBitVal(state,Value68_Present_GetBit(state),prs);
 3877            state.Value68 = 0;
 3878        }
 3879        bool prs = !lib_fast::DecodeNull(from);
 3880        if (prs) {
 3881            if (!Value68_PresentQ(state)) {
 3882                state.Value68 = 0;
 3883            }
 3884            ok = lib_fast::DecodeDeltaSigned(from,state.Value68,parent.Value68,true);
 3885            if (!ok) {
 3886                state.error << "fasttest.I32DeltaNull.Value68: bad Signed delta" << eol;
 3887            }
 3888            state.Value68 = parent.Value68;
 3889        }
 3890        pmask_qSetBitVal(parent,Value68_Present_GetBit(parent),prs);
 3891        present_qSetBitVal(state,Value68_Present_GetBit(state),prs);
 3892    }
 3893    (void)pmap;//only to avoid -Wunused-parameter
 3894    return ok;
 3895}
 3896
 3897// --- fasttest.I32DeltaNull..FixEncode
 3898void fasttest::I32DeltaNull_FixEncode(cstring& buf, fasttest::I32DeltaNull& parent, char soh) {
 3899    if (Value68_PresentQ(parent)) {
 3900        buf << "1=" << parent.Value68 << soh;
 3901    }
 3902}
 3903
 3904// --- fasttest.I32DeltaOpt.base.CopyOut
 3905// Copy fields out of row
 3906void fasttest::parent_CopyOut(fasttest::I32DeltaOpt &row, fasttest::TemplateHeader &out) {
 3907    // length: field value is computed
 3908    // id: field value is computed
 3909    (void)row;//only to avoid -Wunused-parameter
 3910    (void)out;//only to avoid -Wunused-parameter
 3911}
 3912
 3913// --- fasttest.I32DeltaOpt.Value67.ReadStrptrMaybe
 3914inline static bool fasttest::Value67_ReadStrptrMaybe(fasttest::I32DeltaOpt &parent, algo::strptr in_str) {
 3915    bool retval = true;
 3916    i32 Value67_tmp;
 3917    retval = i32_ReadStrptrMaybe(Value67_tmp, in_str);
 3918    if (retval) {
 3919        Value67_Set(parent, Value67_tmp);
 3920    }
 3921    return retval;
 3922}
 3923
 3924// --- fasttest.I32DeltaOpt.pmask_bitcurs.Next
 3925// proceed to next item
 3926void fasttest::I32DeltaOpt_pmask_bitcurs_Next(I32DeltaOpt_pmask_bitcurs &curs) {
 3927    ++curs.bit;
 3928    int index = curs.bit / 32;
 3929    int offset = curs.bit % 32;
 3930    for (; index < curs.n_elems; ++index, offset = 0) {
 3931        u64 rest = curs.elems[index] >> offset;
 3932        if (rest) {
 3933            offset += algo::u64_BitScanForward(rest);
 3934            break;
 3935        }
 3936    }
 3937    curs.bit = index * 32 + offset;
 3938}
 3939
 3940// --- fasttest.I32DeltaOpt..ReadFieldMaybe
 3941bool fasttest::I32DeltaOpt_ReadFieldMaybe(fasttest::I32DeltaOpt& parent, algo::strptr field, algo::strptr strval) {
 3942    bool retval = true;
 3943    fasttest::FieldId field_id;
 3944    (void)value_SetStrptrMaybe(field_id,field);
 3945    switch(field_id) {
 3946        case fasttest_FieldId_base: {
 3947            retval = false;
 3948            break;
 3949        }
 3950        case fasttest_FieldId_length: {
 3951            retval = false;
 3952            break;
 3953        }
 3954        case fasttest_FieldId_id: {
 3955            retval = false;
 3956            break;
 3957        }
 3958        case fasttest_FieldId_pmask: {
 3959            retval = false;
 3960            break;
 3961        }
 3962        case fasttest_FieldId_Value67: {
 3963            retval = Value67_ReadStrptrMaybe(parent, strval);
 3964            if (retval) {
 3965                pmask_qSetBit(parent, 0);
 3966            }
 3967            break;
 3968        }
 3969        default: break;
 3970    }
 3971    if (!retval) {
 3972        algo_lib::AppendErrtext("attr",field);
 3973    }
 3974    return retval;
 3975}
 3976
 3977// --- fasttest.I32DeltaOpt..ReadStrptrMaybe
 3978// Read fields of fasttest::I32DeltaOpt from an ascii string.
 3979// The format of the string is an ssim Tuple
 3980bool fasttest::I32DeltaOpt_ReadStrptrMaybe(fasttest::I32DeltaOpt &parent, algo::strptr in_str) {
 3981    bool retval = true;
 3982    retval = algo::StripTypeTag(in_str, "fasttest.I32DeltaOpt");
 3983    ind_beg(algo::Attr_curs, attr, in_str) {
 3984        retval = retval && I32DeltaOpt_ReadFieldMaybe(parent, attr.name, attr.value);
 3985    }ind_end;
 3986    return retval;
 3987}
 3988
 3989// --- fasttest.I32DeltaOpt..Print
 3990// print string representation of ROW to string STR
 3991// cfmt:fasttest.I32DeltaOpt.String  printfmt:Tuple
 3992void fasttest::I32DeltaOpt_Print(fasttest::I32DeltaOpt& row, algo::cstring& str) {
 3993    algo::tempstr temp;
 3994    str << "fasttest.I32DeltaOpt";
 3995
 3996    if (Value67_PresentQ(row)) {
 3997        i32_Print(row.Value67, temp);
 3998        PrintAttrSpaceReset(str,"Value67", temp);
 3999    }
 4000}
 4001
 4002// --- fasttest.I32DeltaOpt..FastEncode
 4003void fasttest::I32DeltaOpt_FastEncode(algo::ByteAry& buf, FastState& state, fasttest::I32DeltaOpt& parent) {
 4004    int index = ary_N(buf);
 4005    u64 pmap(0);
 4006    if (!tid_AssignedQ(state) || parent.id != state.tid) {
 4007        lib_fast::EncodeUnsigned(buf,parent.id,false);
 4008        lib_fast::SetPmapBit(pmap,0);
 4009    }
 4010    tid_SetAssigned(state);
 4011    state.tid = parent.id;
 4012    // Value67 signed delta optional
 4013    if (!Value67_AssignedQ(state)) {
 4014        Value67_SetAssigned(state);
 4015        present_qSetBitVal(state,Value67_Present_GetBit(state),Value67_PresentQ(parent));
 4016        state.Value67 = 67;
 4017    }
 4018    if (Value67_PresentQ(parent)) {
 4019        if (!Value67_PresentQ(state)) {
 4020            state.Value67 = 67;
 4021        }
 4022        lib_fast::EncodeDeltaSigned(buf,state.Value67,parent.Value67,true);
 4023    } else {
 4024        lib_fast::EncodeNull(buf);
 4025    }
 4026    state.Value67 = parent.Value67;
 4027    present_qSetBitVal(state,Value67_Present_GetBit(state),Value67_PresentQ(parent));
 4028    lib_fast::InsertPmap(buf,index,pmap);
 4029}
 4030
 4031// --- fasttest.I32DeltaOpt..FastDecode
 4032bool fasttest::I32DeltaOpt_FastDecode(algo::memptr& from, u64 pmap, FastState& state, fasttest::I32DeltaOpt& parent) {
 4033    bool ok = true;
 4034    // Value67 signed delta optional
 4035    if (ok) {
 4036        if (!Value67_AssignedQ(state)) {
 4037            Value67_SetAssigned(state);
 4038            bool prs(true);
 4039            present_qSetBitVal(state,Value67_Present_GetBit(state),prs);
 4040            state.Value67 = 67;
 4041        }
 4042        bool prs = !lib_fast::DecodeNull(from);
 4043        if (prs) {
 4044            if (!Value67_PresentQ(state)) {
 4045                state.Value67 = 67;
 4046            }
 4047            ok = lib_fast::DecodeDeltaSigned(from,state.Value67,parent.Value67,true);
 4048            if (!ok) {
 4049                state.error << "fasttest.I32DeltaOpt.Value67: bad Signed delta" << eol;
 4050            }
 4051            state.Value67 = parent.Value67;
 4052        }
 4053        pmask_qSetBitVal(parent,Value67_Present_GetBit(parent),prs);
 4054        present_qSetBitVal(state,Value67_Present_GetBit(state),prs);
 4055    }
 4056    (void)pmap;//only to avoid -Wunused-parameter
 4057    return ok;
 4058}
 4059
 4060// --- fasttest.I32DeltaOpt..FixEncode
 4061void fasttest::I32DeltaOpt_FixEncode(cstring& buf, fasttest::I32DeltaOpt& parent, char soh) {
 4062    if (Value67_PresentQ(parent)) {
 4063        buf << "1=" << parent.Value67 << soh;
 4064    }
 4065}
 4066
 4067// --- fasttest.I32Dflt.base.CopyOut
 4068// Copy fields out of row
 4069void fasttest::parent_CopyOut(fasttest::I32Dflt &row, fasttest::TemplateHeader &out) {
 4070    // length: field value is computed
 4071    // id: field value is computed
 4072    (void)row;//only to avoid -Wunused-parameter
 4073    (void)out;//only to avoid -Wunused-parameter
 4074}
 4075
 4076// --- fasttest.I32Dflt..ReadFieldMaybe
 4077bool fasttest::I32Dflt_ReadFieldMaybe(fasttest::I32Dflt& parent, algo::strptr field, algo::strptr strval) {
 4078    bool retval = true;
 4079    fasttest::FieldId field_id;
 4080    (void)value_SetStrptrMaybe(field_id,field);
 4081    switch(field_id) {
 4082        case fasttest_FieldId_base: {
 4083            retval = false;
 4084            break;
 4085        }
 4086        case fasttest_FieldId_length: {
 4087            retval = false;
 4088            break;
 4089        }
 4090        case fasttest_FieldId_id: {
 4091            retval = false;
 4092            break;
 4093        }
 4094        case fasttest_FieldId_Value: {
 4095            retval = i32_ReadStrptrMaybe(parent.Value, strval);
 4096            break;
 4097        }
 4098        default: break;
 4099    }
 4100    if (!retval) {
 4101        algo_lib::AppendErrtext("attr",field);
 4102    }
 4103    return retval;
 4104}
 4105
 4106// --- fasttest.I32Dflt..ReadStrptrMaybe
 4107// Read fields of fasttest::I32Dflt from an ascii string.
 4108// The format of the string is an ssim Tuple
 4109bool fasttest::I32Dflt_ReadStrptrMaybe(fasttest::I32Dflt &parent, algo::strptr in_str) {
 4110    bool retval = true;
 4111    retval = algo::StripTypeTag(in_str, "fasttest.I32Dflt");
 4112    ind_beg(algo::Attr_curs, attr, in_str) {
 4113        retval = retval && I32Dflt_ReadFieldMaybe(parent, attr.name, attr.value);
 4114    }ind_end;
 4115    return retval;
 4116}
 4117
 4118// --- fasttest.I32Dflt..Print
 4119// print string representation of ROW to string STR
 4120// cfmt:fasttest.I32Dflt.String  printfmt:Tuple
 4121void fasttest::I32Dflt_Print(fasttest::I32Dflt& row, algo::cstring& str) {
 4122    algo::tempstr temp;
 4123    str << "fasttest.I32Dflt";
 4124
 4125    i32_Print(row.Value, temp);
 4126    PrintAttrSpaceReset(str,"Value", temp);
 4127}
 4128
 4129// --- fasttest.I32Dflt..FastEncode
 4130void fasttest::I32Dflt_FastEncode(algo::ByteAry& buf, FastState& state, fasttest::I32Dflt& parent) {
 4131    int index = ary_N(buf);
 4132    u64 pmap(0);
 4133    if (!tid_AssignedQ(state) || parent.id != state.tid) {
 4134        lib_fast::EncodeUnsigned(buf,parent.id,false);
 4135        lib_fast::SetPmapBit(pmap,0);
 4136    }
 4137    tid_SetAssigned(state);
 4138    state.tid = parent.id;
 4139    // Value signed default mandatory
 4140    if (parent.Value != 33) {
 4141        lib_fast::EncodeSigned(buf,parent.Value,false);
 4142        lib_fast::SetPmapBit(pmap,1);
 4143    }
 4144    lib_fast::InsertPmap(buf,index,pmap);
 4145}
 4146
 4147// --- fasttest.I32Dflt..FastDecode
 4148bool fasttest::I32Dflt_FastDecode(algo::memptr& from, u64 pmap, FastState& state, fasttest::I32Dflt& parent) {
 4149    bool ok = true;
 4150    // Value signed default mandatory
 4151    if (ok) {
 4152        bool prs = lib_fast::GetPmapBit(pmap,1);
 4153        if (prs) {
 4154            ok = lib_fast::DecodeSigned(from,parent.Value,false);
 4155            if (!ok) {
 4156                state.error << "fasttest.I32Dflt.Value: bad Signed" << eol;
 4157            }
 4158        } else {
 4159            parent.Value = 33;
 4160        }
 4161    }
 4162    return ok;
 4163}
 4164
 4165// --- fasttest.I32Dflt..FixEncode
 4166void fasttest::I32Dflt_FixEncode(cstring& buf, fasttest::I32Dflt& parent, char soh) {
 4167    buf << "1=" << parent.Value << soh;
 4168}
 4169
 4170// --- fasttest.I32DfltNull.base.CopyOut
 4171// Copy fields out of row
 4172void fasttest::parent_CopyOut(fasttest::I32DfltNull &row, fasttest::TemplateHeader &out) {
 4173    // length: field value is computed
 4174    // id: field value is computed
 4175    (void)row;//only to avoid -Wunused-parameter
 4176    (void)out;//only to avoid -Wunused-parameter
 4177}
 4178
 4179// --- fasttest.I32DfltNull.Value.ReadStrptrMaybe
 4180inline static bool fasttest::Value_ReadStrptrMaybe(fasttest::I32DfltNull &parent, algo::strptr in_str) {
 4181    bool retval = true;
 4182    i32 Value_tmp;
 4183    retval = i32_ReadStrptrMaybe(Value_tmp, in_str);
 4184    if (retval) {
 4185        Value_Set(parent, Value_tmp);
 4186    }
 4187    return retval;
 4188}
 4189
 4190// --- fasttest.I32DfltNull.pmask_bitcurs.Next
 4191// proceed to next item
 4192void fasttest::I32DfltNull_pmask_bitcurs_Next(I32DfltNull_pmask_bitcurs &curs) {
 4193    ++curs.bit;
 4194    int index = curs.bit / 32;
 4195    int offset = curs.bit % 32;
 4196    for (; index < curs.n_elems; ++index, offset = 0) {
 4197        u64 rest = curs.elems[index] >> offset;
 4198        if (rest) {
 4199            offset += algo::u64_BitScanForward(rest);
 4200            break;
 4201        }
 4202    }
 4203    curs.bit = index * 32 + offset;
 4204}
 4205
 4206// --- fasttest.I32DfltNull..ReadFieldMaybe
 4207bool fasttest::I32DfltNull_ReadFieldMaybe(fasttest::I32DfltNull& parent, algo::strptr field, algo::strptr strval) {
 4208    bool retval = true;
 4209    fasttest::FieldId field_id;
 4210    (void)value_SetStrptrMaybe(field_id,field);
 4211    switch(field_id) {
 4212        case fasttest_FieldId_base: {
 4213            retval = false;
 4214            break;
 4215        }
 4216        case fasttest_FieldId_length: {
 4217            retval = false;
 4218            break;
 4219        }
 4220        case fasttest_FieldId_id: {
 4221            retval = false;
 4222            break;
 4223        }
 4224        case fasttest_FieldId_pmask: {
 4225            retval = false;
 4226            break;
 4227        }
 4228        case fasttest_FieldId_Value: {
 4229            retval = Value_ReadStrptrMaybe(parent, strval);
 4230            if (retval) {
 4231                pmask_qSetBit(parent, 0);
 4232            }
 4233            break;
 4234        }
 4235        default: break;
 4236    }
 4237    if (!retval) {
 4238        algo_lib::AppendErrtext("attr",field);
 4239    }
 4240    return retval;
 4241}
 4242
 4243// --- fasttest.I32DfltNull..ReadStrptrMaybe
 4244// Read fields of fasttest::I32DfltNull from an ascii string.
 4245// The format of the string is an ssim Tuple
 4246bool fasttest::I32DfltNull_ReadStrptrMaybe(fasttest::I32DfltNull &parent, algo::strptr in_str) {
 4247    bool retval = true;
 4248    retval = algo::StripTypeTag(in_str, "fasttest.I32DfltNull");
 4249    ind_beg(algo::Attr_curs, attr, in_str) {
 4250        retval = retval && I32DfltNull_ReadFieldMaybe(parent, attr.name, attr.value);
 4251    }ind_end;
 4252    return retval;
 4253}
 4254
 4255// --- fasttest.I32DfltNull..Print
 4256// print string representation of ROW to string STR
 4257// cfmt:fasttest.I32DfltNull.String  printfmt:Tuple
 4258void fasttest::I32DfltNull_Print(fasttest::I32DfltNull& row, algo::cstring& str) {
 4259    algo::tempstr temp;
 4260    str << "fasttest.I32DfltNull";
 4261
 4262    if (Value_PresentQ(row)) {
 4263        i32_Print(row.Value, temp);
 4264        PrintAttrSpaceReset(str,"Value", temp);
 4265    }
 4266}
 4267
 4268// --- fasttest.I32DfltNull..FastEncode
 4269void fasttest::I32DfltNull_FastEncode(algo::ByteAry& buf, FastState& state, fasttest::I32DfltNull& parent) {
 4270    int index = ary_N(buf);
 4271    u64 pmap(0);
 4272    if (!tid_AssignedQ(state) || parent.id != state.tid) {
 4273        lib_fast::EncodeUnsigned(buf,parent.id,false);
 4274        lib_fast::SetPmapBit(pmap,0);
 4275    }
 4276    tid_SetAssigned(state);
 4277    state.tid = parent.id;
 4278    // Value signed default optional
 4279    if (Value_PresentQ(parent)) {
 4280        lib_fast::EncodeSigned(buf,parent.Value,true);
 4281        lib_fast::SetPmapBit(pmap,1);
 4282    }
 4283    lib_fast::InsertPmap(buf,index,pmap);
 4284}
 4285
 4286// --- fasttest.I32DfltNull..FastDecode
 4287bool fasttest::I32DfltNull_FastDecode(algo::memptr& from, u64 pmap, FastState& state, fasttest::I32DfltNull& parent) {
 4288    bool ok = true;
 4289    // Value signed default optional
 4290    if (ok) {
 4291        bool prs = lib_fast::GetPmapBit(pmap,1);
 4292        if (prs) {
 4293            prs = !lib_fast::DecodeNull(from);
 4294            if (prs) {
 4295                ok = lib_fast::DecodeSigned(from,parent.Value,true);
 4296                if (!ok) {
 4297                    state.error << "fasttest.I32DfltNull.Value: bad Signed" << eol;
 4298                }
 4299            }
 4300        } else {
 4301        }
 4302        pmask_qSetBitVal(parent,Value_Present_GetBit(parent),prs);
 4303    }
 4304    return ok;
 4305}
 4306
 4307// --- fasttest.I32DfltNull..FixEncode
 4308void fasttest::I32DfltNull_FixEncode(cstring& buf, fasttest::I32DfltNull& parent, char soh) {
 4309    if (Value_PresentQ(parent)) {
 4310        buf << "1=" << parent.Value << soh;
 4311    }
 4312}
 4313
 4314// --- fasttest.I32DfltOpt.base.CopyOut
 4315// Copy fields out of row
 4316void fasttest::parent_CopyOut(fasttest::I32DfltOpt &row, fasttest::TemplateHeader &out) {
 4317    // length: field value is computed
 4318    // id: field value is computed
 4319    (void)row;//only to avoid -Wunused-parameter
 4320    (void)out;//only to avoid -Wunused-parameter
 4321}
 4322
 4323// --- fasttest.I32DfltOpt.Value.ReadStrptrMaybe
 4324inline static bool fasttest::Value_ReadStrptrMaybe(fasttest::I32DfltOpt &parent, algo::strptr in_str) {
 4325    bool retval = true;
 4326    i32 Value_tmp;
 4327    retval = i32_ReadStrptrMaybe(Value_tmp, in_str);
 4328    if (retval) {
 4329        Value_Set(parent, Value_tmp);
 4330    }
 4331    return retval;
 4332}
 4333
 4334// --- fasttest.I32DfltOpt.pmask_bitcurs.Next
 4335// proceed to next item
 4336void fasttest::I32DfltOpt_pmask_bitcurs_Next(I32DfltOpt_pmask_bitcurs &curs) {
 4337    ++curs.bit;
 4338    int index = curs.bit / 32;
 4339    int offset = curs.bit % 32;
 4340    for (; index < curs.n_elems; ++index, offset = 0) {
 4341        u64 rest = curs.elems[index] >> offset;
 4342        if (rest) {
 4343            offset += algo::u64_BitScanForward(rest);
 4344            break;
 4345        }
 4346    }
 4347    curs.bit = index * 32 + offset;
 4348}
 4349
 4350// --- fasttest.I32DfltOpt..ReadFieldMaybe
 4351bool fasttest::I32DfltOpt_ReadFieldMaybe(fasttest::I32DfltOpt& parent, algo::strptr field, algo::strptr strval) {
 4352    bool retval = true;
 4353    fasttest::FieldId field_id;
 4354    (void)value_SetStrptrMaybe(field_id,field);
 4355    switch(field_id) {
 4356        case fasttest_FieldId_base: {
 4357            retval = false;
 4358            break;
 4359        }
 4360        case fasttest_FieldId_length: {
 4361            retval = false;
 4362            break;
 4363        }
 4364        case fasttest_FieldId_id: {
 4365            retval = false;
 4366            break;
 4367        }
 4368        case fasttest_FieldId_pmask: {
 4369            retval = false;
 4370            break;
 4371        }
 4372        case fasttest_FieldId_Value: {
 4373            retval = Value_ReadStrptrMaybe(parent, strval);
 4374            if (retval) {
 4375                pmask_qSetBit(parent, 0);
 4376            }
 4377            break;
 4378        }
 4379        default: break;
 4380    }
 4381    if (!retval) {
 4382        algo_lib::AppendErrtext("attr",field);
 4383    }
 4384    return retval;
 4385}
 4386
 4387// --- fasttest.I32DfltOpt..ReadStrptrMaybe
 4388// Read fields of fasttest::I32DfltOpt from an ascii string.
 4389// The format of the string is an ssim Tuple
 4390bool fasttest::I32DfltOpt_ReadStrptrMaybe(fasttest::I32DfltOpt &parent, algo::strptr in_str) {
 4391    bool retval = true;
 4392    retval = algo::StripTypeTag(in_str, "fasttest.I32DfltOpt");
 4393    ind_beg(algo::Attr_curs, attr, in_str) {
 4394        retval = retval && I32DfltOpt_ReadFieldMaybe(parent, attr.name, attr.value);
 4395    }ind_end;
 4396    return retval;
 4397}
 4398
 4399// --- fasttest.I32DfltOpt..Print
 4400// print string representation of ROW to string STR
 4401// cfmt:fasttest.I32DfltOpt.String  printfmt:Tuple
 4402void fasttest::I32DfltOpt_Print(fasttest::I32DfltOpt& row, algo::cstring& str) {
 4403    algo::tempstr temp;
 4404    str << "fasttest.I32DfltOpt";
 4405
 4406    if (Value_PresentQ(row)) {
 4407        i32_Print(row.Value, temp);
 4408        PrintAttrSpaceReset(str,"Value", temp);
 4409    }
 4410}
 4411
 4412// --- fasttest.I32DfltOpt..FastEncode
 4413void fasttest::I32DfltOpt_FastEncode(algo::ByteAry& buf, FastState& state, fasttest::I32DfltOpt& parent) {
 4414    int index = ary_N(buf);
 4415    u64 pmap(0);
 4416    if (!tid_AssignedQ(state) || parent.id != state.tid) {
 4417        lib_fast::EncodeUnsigned(buf,parent.id,false);
 4418        lib_fast::SetPmapBit(pmap,0);
 4419    }
 4420    tid_SetAssigned(state);
 4421    state.tid = parent.id;
 4422    // Value signed default optional
 4423    if (Value_PresentQ(parent)) {
 4424        if (parent.Value != 34) {
 4425            lib_fast::EncodeSigned(buf,parent.Value,true);
 4426            lib_fast::SetPmapBit(pmap,1);
 4427        }
 4428    } else {
 4429        lib_fast::EncodeNull(buf);
 4430        lib_fast::SetPmapBit(pmap,1);
 4431    }
 4432    lib_fast::InsertPmap(buf,index,pmap);
 4433}
 4434
 4435// --- fasttest.I32DfltOpt..FastDecode
 4436bool fasttest::I32DfltOpt_FastDecode(algo::memptr& from, u64 pmap, FastState& state, fasttest::I32DfltOpt& parent) {
 4437    bool ok = true;
 4438    // Value signed default optional
 4439    if (ok) {
 4440        bool prs = lib_fast::GetPmapBit(pmap,1);
 4441        if (prs) {
 4442            prs = !lib_fast::DecodeNull(from);
 4443            if (prs) {
 4444                ok = lib_fast::DecodeSigned(from,parent.Value,true);
 4445                if (!ok) {
 4446                    state.error << "fasttest.I32DfltOpt.Value: bad Signed" << eol;
 4447                }
 4448            }
 4449        } else {
 4450            parent.Value = 34;
 4451            prs = true;
 4452        }
 4453        pmask_qSetBitVal(parent,Value_Present_GetBit(parent),prs);
 4454    }
 4455    return ok;
 4456}
 4457
 4458// --- fasttest.I32DfltOpt..FixEncode
 4459void fasttest::I32DfltOpt_FixEncode(cstring& buf, fasttest::I32DfltOpt& parent, char soh) {
 4460    if (Value_PresentQ(parent)) {
 4461        buf << "1=" << parent.Value << soh;
 4462    }
 4463}
 4464
 4465// --- fasttest.I32Incr.base.CopyOut
 4466// Copy fields out of row
 4467void fasttest::parent_CopyOut(fasttest::I32Incr &row, fasttest::TemplateHeader &out) {
 4468    // length: field value is computed
 4469    // id: field value is computed
 4470    (void)row;//only to avoid -Wunused-parameter
 4471    (void)out;//only to avoid -Wunused-parameter
 4472}
 4473
 4474// --- fasttest.I32Incr..ReadFieldMaybe
 4475bool fasttest::I32Incr_ReadFieldMaybe(fasttest::I32Incr& parent, algo::strptr field, algo::strptr strval) {
 4476    bool retval = true;
 4477    fasttest::FieldId field_id;
 4478    (void)value_SetStrptrMaybe(field_id,field);
 4479    switch(field_id) {
 4480        case fasttest_FieldId_base: {
 4481            retval = false;
 4482            break;
 4483        }
 4484        case fasttest_FieldId_length: {
 4485            retval = false;
 4486            break;
 4487        }
 4488        case fasttest_FieldId_id: {
 4489            retval = false;
 4490            break;
 4491        }
 4492        case fasttest_FieldId_Value97: {
 4493            retval = i32_ReadStrptrMaybe(parent.Value97, strval);
 4494            break;
 4495        }
 4496        default: break;
 4497    }
 4498    if (!retval) {
 4499        algo_lib::AppendErrtext("attr",field);
 4500    }
 4501    return retval;
 4502}
 4503
 4504// --- fasttest.I32Incr..ReadStrptrMaybe
 4505// Read fields of fasttest::I32Incr from an ascii string.
 4506// The format of the string is an ssim Tuple
 4507bool fasttest::I32Incr_ReadStrptrMaybe(fasttest::I32Incr &parent, algo::strptr in_str) {
 4508    bool retval = true;
 4509    retval = algo::StripTypeTag(in_str, "fasttest.I32Incr");
 4510    ind_beg(algo::Attr_curs, attr, in_str) {
 4511        retval = retval && I32Incr_ReadFieldMaybe(parent, attr.name, attr.value);
 4512    }ind_end;
 4513    return retval;
 4514}
 4515
 4516// --- fasttest.I32Incr..Print
 4517// print string representation of ROW to string STR
 4518// cfmt:fasttest.I32Incr.String  printfmt:Tuple
 4519void fasttest::I32Incr_Print(fasttest::I32Incr& row, algo::cstring& str) {
 4520    algo::tempstr temp;
 4521    str << "fasttest.I32Incr";
 4522
 4523    i32_Print(row.Value97, temp);
 4524    PrintAttrSpaceReset(str,"Value97", temp);
 4525}
 4526
 4527// --- fasttest.I32Incr..FastEncode
 4528void fasttest::I32Incr_FastEncode(algo::ByteAry& buf, FastState& state, fasttest::I32Incr& parent) {
 4529    int index = ary_N(buf);
 4530    u64 pmap(0);
 4531    if (!tid_AssignedQ(state) || parent.id != state.tid) {
 4532        lib_fast::EncodeUnsigned(buf,parent.id,false);
 4533        lib_fast::SetPmapBit(pmap,0);
 4534    }
 4535    tid_SetAssigned(state);
 4536    state.tid = parent.id;
 4537    // Value97 signed increment mandatory
 4538    if (Value97_AssignedQ(state)) {
 4539        if (parent.Value97 != state.Value97 + 1) {
 4540            lib_fast::EncodeSigned(buf,parent.Value97,false);
 4541            lib_fast::SetPmapBit(pmap,1);
 4542        }
 4543    } else {
 4544        if (parent.Value97 != 97) {
 4545            lib_fast::EncodeSigned(buf,parent.Value97,false);
 4546            lib_fast::SetPmapBit(pmap,1);
 4547        }
 4548    }
 4549    state.Value97 = parent.Value97;
 4550    Value97_SetAssigned(state);
 4551    lib_fast::InsertPmap(buf,index,pmap);
 4552}
 4553
 4554// --- fasttest.I32Incr..FastDecode
 4555bool fasttest::I32Incr_FastDecode(algo::memptr& from, u64 pmap, FastState& state, fasttest::I32Incr& parent) {
 4556    bool ok = true;
 4557    // Value97 signed increment mandatory
 4558    if (ok) {
 4559        bool prs = lib_fast::GetPmapBit(pmap,1);
 4560        if (prs) {
 4561            ok = lib_fast::DecodeSigned(from,parent.Value97,false);
 4562            if (!ok) {
 4563                state.error << "fasttest.I32Incr.Value97: bad Signed" << eol;
 4564            }
 4565        } else if (Value97_AssignedQ(state)) {
 4566            parent.Value97 = state.Value97 + 1;
 4567        } else {
 4568            parent.Value97 = 97;
 4569        }
 4570        Value97_SetAssigned(state);
 4571        state.Value97 = parent.Value97;
 4572    }
 4573    return ok;
 4574}
 4575
 4576// --- fasttest.I32Incr..FixEncode
 4577void fasttest::I32Incr_FixEncode(cstring& buf, fasttest::I32Incr& parent, char soh) {
 4578    buf << "1=" << parent.Value97 << soh;
 4579}
 4580
 4581// --- fasttest.I32IncrNV.base.CopyOut
 4582// Copy fields out of row
 4583void fasttest::parent_CopyOut(fasttest::I32IncrNV &row, fasttest::TemplateHeader &out) {
 4584    // length: field value is computed
 4585    // id: field value is computed
 4586    (void)row;//only to avoid -Wunused-parameter
 4587    (void)out;//only to avoid -Wunused-parameter
 4588}
 4589
 4590// --- fasttest.I32IncrNV..ReadFieldMaybe
 4591bool fasttest::I32IncrNV_ReadFieldMaybe(fasttest::I32IncrNV& parent, algo::strptr field, algo::strptr strval) {
 4592    bool retval = true;
 4593    fasttest::FieldId field_id;
 4594    (void)value_SetStrptrMaybe(field_id,field);
 4595    switch(field_id) {
 4596        case fasttest_FieldId_base: {
 4597            retval = false;
 4598            break;
 4599        }
 4600        case fasttest_FieldId_length: {
 4601            retval = false;
 4602            break;
 4603        }
 4604        case fasttest_FieldId_id: {
 4605            retval = false;
 4606            break;
 4607        }
 4608        case fasttest_FieldId_Value98: {
 4609            retval = i32_ReadStrptrMaybe(parent.Value98, strval);
 4610            break;
 4611        }
 4612        default: break;
 4613    }
 4614    if (!retval) {
 4615        algo_lib::AppendErrtext("attr",field);
 4616    }
 4617    return retval;
 4618}
 4619
 4620// --- fasttest.I32IncrNV..ReadStrptrMaybe
 4621// Read fields of fasttest::I32IncrNV from an ascii string.
 4622// The format of the string is an ssim Tuple
 4623bool fasttest::I32IncrNV_ReadStrptrMaybe(fasttest::I32IncrNV &parent, algo::strptr in_str) {
 4624    bool retval = true;
 4625    retval = algo::StripTypeTag(in_str, "fasttest.I32IncrNV");
 4626    ind_beg(algo::Attr_curs, attr, in_str) {
 4627        retval = retval && I32IncrNV_ReadFieldMaybe(parent, attr.name, attr.value);
 4628    }ind_end;
 4629    return retval;
 4630}
 4631
 4632// --- fasttest.I32IncrNV..Print
 4633// print string representation of ROW to string STR
 4634// cfmt:fasttest.I32IncrNV.String  printfmt:Tuple
 4635void fasttest::I32IncrNV_Print(fasttest::I32IncrNV& row, algo::cstring& str) {
 4636    algo::tempstr temp;
 4637    str << "fasttest.I32IncrNV";
 4638
 4639    i32_Print(row.Value98, temp);
 4640    PrintAttrSpaceReset(str,"Value98", temp);
 4641}
 4642
 4643// --- fasttest.I32IncrNV..FastEncode
 4644void fasttest::I32IncrNV_FastEncode(algo::ByteAry& buf, FastState& state, fasttest::I32IncrNV& parent) {
 4645    int index = ary_N(buf);
 4646    u64 pmap(0);
 4647    if (!tid_AssignedQ(state) || parent.id != state.tid) {
 4648        lib_fast::EncodeUnsigned(buf,parent.id,false);
 4649        lib_fast::SetPmapBit(pmap,0);
 4650    }
 4651    tid_SetAssigned(state);
 4652    state.tid = parent.id;
 4653    // Value98 signed increment mandatory
 4654    if (Value98_AssignedQ(state)) {
 4655        if (parent.Value98 != state.Value98 + 1) {
 4656            lib_fast::EncodeSigned(buf,parent.Value98,false);
 4657            lib_fast::SetPmapBit(pmap,1);
 4658        }
 4659    } else {
 4660        lib_fast::EncodeSigned(buf,parent.Value98,false);
 4661        lib_fast::SetPmapBit(pmap,1);
 4662    }
 4663    state.Value98 = parent.Value98;
 4664    Value98_SetAssigned(state);
 4665    lib_fast::InsertPmap(buf,index,pmap);
 4666}
 4667
 4668// --- fasttest.I32IncrNV..FastDecode
 4669bool fasttest::I32IncrNV_FastDecode(algo::memptr& from, u64 pmap, FastState& state, fasttest::I32IncrNV& parent) {
 4670    bool ok = true;
 4671    // Value98 signed increment mandatory
 4672    if (ok) {
 4673        bool prs = lib_fast::GetPmapBit(pmap,1);
 4674        if (prs) {
 4675            ok = lib_fast::DecodeSigned(from,parent.Value98,false);
 4676            if (!ok) {
 4677                state.error << "fasttest.I32IncrNV.Value98: bad Signed" << eol;
 4678            }
 4679        } else if (Value98_AssignedQ(state)) {
 4680            parent.Value98 = state.Value98 + 1;
 4681        } else {
 4682            ok = false;
 4683            state.error << "fasttest.I32IncrNV.Value98: increment operator: previous value unassigned" << eol;
 4684        }
 4685        Value98_SetAssigned(state);
 4686        state.Value98 = parent.Value98;
 4687    }
 4688    return ok;
 4689}
 4690
 4691// --- fasttest.I32IncrNV..FixEncode
 4692void fasttest::I32IncrNV_FixEncode(cstring& buf, fasttest::I32IncrNV& parent, char soh) {
 4693    buf << "1=" << parent.Value98 << soh;
 4694}
 4695
 4696// --- fasttest.I32IncrNull.base.CopyOut
 4697// Copy fields out of row
 4698void fasttest::parent_CopyOut(fasttest::I32IncrNull &row, fasttest::TemplateHeader &out) {
 4699    // length: field value is computed
 4700    // id: field value is computed
 4701    (void)row;//only to avoid -Wunused-parameter
 4702    (void)out;//only to avoid -Wunused-parameter
 4703}
 4704
 4705// --- fasttest.I32IncrNull.Value100.ReadStrptrMaybe
 4706inline static bool fasttest::Value100_ReadStrptrMaybe(fasttest::I32IncrNull &parent, algo::strptr in_str) {
 4707    bool retval = true;
 4708    i32 Value100_tmp;
 4709    retval = i32_ReadStrptrMaybe(Value100_tmp, in_str);
 4710    if (retval) {
 4711        Value100_Set(parent, Value100_tmp);
 4712    }
 4713    return retval;
 4714}
 4715
 4716// --- fasttest.I32IncrNull.pmask_bitcurs.Next
 4717// proceed to next item
 4718void fasttest::I32IncrNull_pmask_bitcurs_Next(I32IncrNull_pmask_bitcurs &curs) {
 4719    ++curs.bit;
 4720    int index = curs.bit / 32;
 4721    int offset = curs.bit % 32;
 4722    for (; index < curs.n_elems; ++index, offset = 0) {
 4723        u64 rest = curs.elems[index] >> offset;
 4724        if (rest) {
 4725            offset += algo::u64_BitScanForward(rest);
 4726            break;
 4727        }
 4728    }
 4729    curs.bit = index * 32 + offset;
 4730}
 4731
 4732// --- fasttest.I32IncrNull..ReadFieldMaybe
 4733bool fasttest::I32IncrNull_ReadFieldMaybe(fasttest::I32IncrNull& parent, algo::strptr field, algo::strptr strval) {
 4734    bool retval = true;
 4735    fasttest::FieldId field_id;
 4736    (void)value_SetStrptrMaybe(field_id,field);
 4737    switch(field_id) {
 4738        case fasttest_FieldId_base: {
 4739            retval = false;
 4740            break;
 4741        }
 4742        case fasttest_FieldId_length: {
 4743            retval = false;
 4744            break;
 4745        }
 4746        case fasttest_FieldId_id: {
 4747            retval = false;
 4748            break;
 4749        }
 4750        case fasttest_FieldId_pmask: {
 4751            retval = false;
 4752            break;
 4753        }
 4754        case fasttest_FieldId_Value100: {
 4755            retval = Value100_ReadStrptrMaybe(parent, strval);
 4756            if (retval) {
 4757                pmask_qSetBit(parent, 0);
 4758            }
 4759            break;
 4760        }
 4761        default: break;
 4762    }
 4763    if (!retval) {
 4764        algo_lib::AppendErrtext("attr",field);
 4765    }
 4766    return retval;
 4767}
 4768
 4769// --- fasttest.I32IncrNull..ReadStrptrMaybe
 4770// Read fields of fasttest::I32IncrNull from an ascii string.
 4771// The format of the string is an ssim Tuple
 4772bool fasttest::I32IncrNull_ReadStrptrMaybe(fasttest::I32IncrNull &parent, algo::strptr in_str) {
 4773    bool retval = true;
 4774    retval = algo::StripTypeTag(in_str, "fasttest.I32IncrNull");
 4775    ind_beg(algo::Attr_curs, attr, in_str) {
 4776        retval = retval && I32IncrNull_ReadFieldMaybe(parent, attr.name, attr.value);
 4777    }ind_end;
 4778    return retval;
 4779}
 4780
 4781// --- fasttest.I32IncrNull..Print
 4782// print string representation of ROW to string STR
 4783// cfmt:fasttest.I32IncrNull.String  printfmt:Tuple
 4784void fasttest::I32IncrNull_Print(fasttest::I32IncrNull& row, algo::cstring& str) {
 4785    algo::tempstr temp;
 4786    str << "fasttest.I32IncrNull";
 4787
 4788    if (Value100_PresentQ(row)) {
 4789        i32_Print(row.Value100, temp);
 4790        PrintAttrSpaceReset(str,"Value100", temp);
 4791    }
 4792}
 4793
 4794// --- fasttest.I32IncrNull..FastEncode
 4795void fasttest::I32IncrNull_FastEncode(algo::ByteAry& buf, FastState& state, fasttest::I32IncrNull& parent) {
 4796    int index = ary_N(buf);
 4797    u64 pmap(0);
 4798    if (!tid_AssignedQ(state) || parent.id != state.tid) {
 4799        lib_fast::EncodeUnsigned(buf,parent.id,false);
 4800        lib_fast::SetPmapBit(pmap,0);
 4801    }
 4802    tid_SetAssigned(state);
 4803    state.tid = parent.id;
 4804    // Value100 signed increment optional
 4805    if (Value100_PresentQ(parent)) {
 4806        if (Value100_AssignedQ(state)) {
 4807            if (!Value100_PresentQ(state) || parent.Value100 != state.Value100 + 1) {
 4808                lib_fast::EncodeSigned(buf,parent.Value100,true);
 4809                lib_fast::SetPmapBit(pmap,1);
 4810            }
 4811        } else {
 4812            lib_fast::EncodeSigned(buf,parent.Value100,true);
 4813            lib_fast::SetPmapBit(pmap,1);
 4814        }
 4815    } else {
 4816        if (!Value100_AssignedQ(state) || Value100_PresentQ(state)) {
 4817            lib_fast::EncodeNull(buf);
 4818            lib_fast::SetPmapBit(pmap,1);
 4819        }
 4820    }
 4821    state.Value100 = parent.Value100;
 4822    present_qSetBitVal(state,Value100_Present_GetBit(state),Value100_PresentQ(parent));
 4823    Value100_SetAssigned(state);
 4824    lib_fast::InsertPmap(buf,index,pmap);
 4825}
 4826
 4827// --- fasttest.I32IncrNull..FastDecode
 4828bool fasttest::I32IncrNull_FastDecode(algo::memptr& from, u64 pmap, FastState& state, fasttest::I32IncrNull& parent) {
 4829    bool ok = true;
 4830    // Value100 signed increment optional
 4831    if (ok) {
 4832        bool prs = lib_fast::GetPmapBit(pmap,1);
 4833        if (prs) {
 4834            prs = !lib_fast::DecodeNull(from);
 4835            if (prs) {
 4836                ok = lib_fast::DecodeSigned(from,parent.Value100,true);
 4837                if (!ok) {
 4838                    state.error << "fasttest.I32IncrNull.Value100: bad Signed" << eol;
 4839                }
 4840            }
 4841        } else if (Value100_AssignedQ(state)) {
 4842            parent.Value100 = state.Value100 + 1;
 4843            prs = Value100_PresentQ(state);
 4844        } else {
 4845            prs = false;
 4846        }
 4847        pmask_qSetBitVal(parent,Value100_Present_GetBit(parent),prs);
 4848        Value100_SetAssigned(state);
 4849        present_qSetBitVal(state,Value100_Present_GetBit(state),prs);
 4850        state.Value100 = parent.Value100;
 4851    }
 4852    return ok;
 4853}
 4854
 4855// --- fasttest.I32IncrNull..FixEncode
 4856void fasttest::I32IncrNull_FixEncode(cstring& buf, fasttest::I32IncrNull& parent, char soh) {
 4857    if (Value100_PresentQ(parent)) {
 4858        buf << "1=" << parent.Value100 << soh;
 4859    }
 4860}
 4861
 4862// --- fasttest.I32IncrOpt.base.CopyOut
 4863// Copy fields out of row
 4864void fasttest::parent_CopyOut(fasttest::I32IncrOpt &row, fasttest::TemplateHeader &out) {
 4865    // length: field value is computed
 4866    // id: field value is computed
 4867    (void)row;//only to avoid -Wunused-parameter
 4868    (void)out;//only to avoid -Wunused-parameter
 4869}
 4870
 4871// --- fasttest.I32IncrOpt.Value99.ReadStrptrMaybe
 4872inline static bool fasttest::Value99_ReadStrptrMaybe(fasttest::I32IncrOpt &parent, algo::strptr in_str) {
 4873    bool retval = true;
 4874    i32 Value99_tmp;
 4875    retval = i32_ReadStrptrMaybe(Value99_tmp, in_str);
 4876    if (retval) {
 4877        Value99_Set(parent, Value99_tmp);
 4878    }
 4879    return retval;
 4880}
 4881
 4882// --- fasttest.I32IncrOpt.pmask_bitcurs.Next
 4883// proceed to next item
 4884void fasttest::I32IncrOpt_pmask_bitcurs_Next(I32IncrOpt_pmask_bitcurs &curs) {
 4885    ++curs.bit;
 4886    int index = curs.bit / 32;
 4887    int offset = curs.bit % 32;
 4888    for (; index < curs.n_elems; ++index, offset = 0) {
 4889        u64 rest = curs.elems[index] >> offset;
 4890        if (rest) {
 4891            offset += algo::u64_BitScanForward(rest);
 4892            break;
 4893        }
 4894    }
 4895    curs.bit = index * 32 + offset;
 4896}
 4897
 4898// --- fasttest.I32IncrOpt..ReadFieldMaybe
 4899bool fasttest::I32IncrOpt_ReadFieldMaybe(fasttest::I32IncrOpt& parent, algo::strptr field, algo::strptr strval) {
 4900    bool retval = true;
 4901    fasttest::FieldId field_id;
 4902    (void)value_SetStrptrMaybe(field_id,field);
 4903    switch(field_id) {
 4904        case fasttest_FieldId_base: {
 4905            retval = false;
 4906            break;
 4907        }
 4908        case fasttest_FieldId_length: {
 4909            retval = false;
 4910            break;
 4911        }
 4912        case fasttest_FieldId_id: {
 4913            retval = false;
 4914            break;
 4915        }
 4916        case fasttest_FieldId_pmask: {
 4917            retval = false;
 4918            break;
 4919        }
 4920        case fasttest_FieldId_Value99: {
 4921            retval = Value99_ReadStrptrMaybe(parent, strval);
 4922            if (retval) {
 4923                pmask_qSetBit(parent, 0);
 4924            }
 4925            break;
 4926        }
 4927        default: break;
 4928    }
 4929    if (!retval) {
 4930        algo_lib::AppendErrtext("attr",field);
 4931    }
 4932    return retval;
 4933}
 4934
 4935// --- fasttest.I32IncrOpt..ReadStrptrMaybe
 4936// Read fields of fasttest::I32IncrOpt from an ascii string.
 4937// The format of the string is an ssim Tuple
 4938bool fasttest::I32IncrOpt_ReadStrptrMaybe(fasttest::I32IncrOpt &parent, algo::strptr in_str) {
 4939    bool retval = true;
 4940    retval = algo::StripTypeTag(in_str, "fasttest.I32IncrOpt");
 4941    ind_beg(algo::Attr_curs, attr, in_str) {
 4942        retval = retval && I32IncrOpt_ReadFieldMaybe(parent, attr.name, attr.value);
 4943    }ind_end;
 4944    return retval;
 4945}
 4946
 4947// --- fasttest.I32IncrOpt..Print
 4948// print string representation of ROW to string STR
 4949// cfmt:fasttest.I32IncrOpt.String  printfmt:Tuple
 4950void fasttest::I32IncrOpt_Print(fasttest::I32IncrOpt& row, algo::cstring& str) {
 4951    algo::tempstr temp;
 4952    str << "fasttest.I32IncrOpt";
 4953
 4954    if (Value99_PresentQ(row)) {
 4955        i32_Print(row.Value99, temp);
 4956        PrintAttrSpaceReset(str,"Value99", temp);
 4957    }
 4958}
 4959
 4960// --- fasttest.I32IncrOpt..FastEncode
 4961void fasttest::I32IncrOpt_FastEncode(algo::ByteAry& buf, FastState& state, fasttest::I32IncrOpt& parent) {
 4962    int index = ary_N(buf);
 4963    u64 pmap(0);
 4964    if (!tid_AssignedQ(state) || parent.id != state.tid) {
 4965        lib_fast::EncodeUnsigned(buf,parent.id,false);
 4966        lib_fast::SetPmapBit(pmap,0);
 4967    }
 4968    tid_SetAssigned(state);
 4969    state.tid = parent.id;
 4970    // Value99 signed increment optional
 4971    if (Value99_PresentQ(parent)) {
 4972        if (Value99_AssignedQ(state)) {
 4973            if (!Value99_PresentQ(state) || parent.Value99 != state.Value99 + 1) {
 4974                lib_fast::EncodeSigned(buf,parent.Value99,true);
 4975                lib_fast::SetPmapBit(pmap,1);
 4976            }
 4977        } else {
 4978            if (parent.Value99 != 99) {
 4979                lib_fast::EncodeSigned(buf,parent.Value99,true);
 4980                lib_fast::SetPmapBit(pmap,1);
 4981            }
 4982        }
 4983    } else {
 4984        if (!Value99_AssignedQ(state) || Value99_PresentQ(state)) {
 4985            lib_fast::EncodeNull(buf);
 4986            lib_fast::SetPmapBit(pmap,1);
 4987        }
 4988    }
 4989    state.Value99 = parent.Value99;
 4990    present_qSetBitVal(state,Value99_Present_GetBit(state),Value99_PresentQ(parent));
 4991    Value99_SetAssigned(state);
 4992    lib_fast::InsertPmap(buf,index,pmap);
 4993}
 4994
 4995// --- fasttest.I32IncrOpt..FastDecode
 4996bool fasttest::I32IncrOpt_FastDecode(algo::memptr& from, u64 pmap, FastState& state, fasttest::I32IncrOpt& parent) {
 4997    bool ok = true;
 4998    // Value99 signed increment optional
 4999    if (ok) {
 5000        bool prs = lib_fast::GetPmapBit(pmap,1);
 5001        if (prs) {
 5002            prs = !lib_fast::DecodeNull(from);
 5003            if (prs) {
 5004                ok = lib_fast::DecodeSigned(from,parent.Value99,true);
 5005                if (!ok) {
 5006                    state.error << "fasttest.I32IncrOpt.Value99: bad Signed" << eol;
 5007                }
 5008            }
 5009        } else if (Value99_AssignedQ(state)) {
 5010            parent.Value99 = state.Value99 + 1;
 5011            prs = Value99_PresentQ(state);
 5012        } else {
 5013            parent.Value99 = 99;
 5014            prs = true;
 5015        }
 5016        pmask_qSetBitVal(parent,Value99_Present_GetBit(parent),prs);
 5017        Value99_SetAssigned(state);
 5018        present_qSetBitVal(state,Value99_Present_GetBit(state),prs);
 5019        state.Value99 = parent.Value99;
 5020    }
 5021    return ok;
 5022}
 5023
 5024// --- fasttest.I32IncrOpt..FixEncode
 5025void fasttest::I32IncrOpt_FixEncode(cstring& buf, fasttest::I32IncrOpt& parent, char soh) {
 5026    if (Value99_PresentQ(parent)) {
 5027        buf << "1=" << parent.Value99 << soh;
 5028    }
 5029}
 5030
 5031// --- fasttest.I32None.base.CopyOut
 5032// Copy fields out of row
 5033void fasttest::parent_CopyOut(fasttest::I32None &row, fasttest::TemplateHeader &out) {
 5034    // length: field value is computed
 5035    // id: field value is computed
 5036    (void)row;//only to avoid -Wunused-parameter
 5037    (void)out;//only to avoid -Wunused-parameter
 5038}
 5039
 5040// --- fasttest.I32None..ReadFieldMaybe
 5041bool fasttest::I32None_ReadFieldMaybe(fasttest::I32None& parent, algo::strptr field, algo::strptr strval) {
 5042    bool retval = true;
 5043    fasttest::FieldId field_id;
 5044    (void)value_SetStrptrMaybe(field_id,field);
 5045    switch(field_id) {
 5046        case fasttest_FieldId_base: {
 5047            retval = false;
 5048            break;
 5049        }
 5050        case fasttest_FieldId_length: {
 5051            retval = false;
 5052            break;
 5053        }
 5054        case fasttest_FieldId_id: {
 5055            retval = false;
 5056            break;
 5057        }
 5058        case fasttest_FieldId_Value: {
 5059            retval = i32_ReadStrptrMaybe(parent.Value, strval);
 5060            break;
 5061        }
 5062        default: break;
 5063    }
 5064    if (!retval) {
 5065        algo_lib::AppendErrtext("attr",field);
 5066    }
 5067    return retval;
 5068}
 5069
 5070// --- fasttest.I32None..ReadStrptrMaybe
 5071// Read fields of fasttest::I32None from an ascii string.
 5072// The format of the string is an ssim Tuple
 5073bool fasttest::I32None_ReadStrptrMaybe(fasttest::I32None &parent, algo::strptr in_str) {
 5074    bool retval = true;
 5075    retval = algo::StripTypeTag(in_str, "fasttest.I32None");
 5076    ind_beg(algo::Attr_curs, attr, in_str) {
 5077        retval = retval && I32None_ReadFieldMaybe(parent, attr.name, attr.value);
 5078    }ind_end;
 5079    return retval;
 5080}
 5081
 5082// --- fasttest.I32None..Print
 5083// print string representation of ROW to string STR
 5084// cfmt:fasttest.I32None.String  printfmt:Tuple
 5085void fasttest::I32None_Print(fasttest::I32None& row, algo::cstring& str) {
 5086    algo::tempstr temp;
 5087    str << "fasttest.I32None";
 5088
 5089    i32_Print(row.Value, temp);
 5090    PrintAttrSpaceReset(str,"Value", temp);
 5091}
 5092
 5093// --- fasttest.I32None..FastEncode
 5094void fasttest::I32None_FastEncode(algo::ByteAry& buf, FastState& state, fasttest::I32None& parent) {
 5095    int index = ary_N(buf);
 5096    u64 pmap(0);
 5097    if (!tid_AssignedQ(state) || parent.id != state.tid) {
 5098        lib_fast::EncodeUnsigned(buf,parent.id,false);
 5099        lib_fast::SetPmapBit(pmap,0);
 5100    }
 5101    tid_SetAssigned(state);
 5102    state.tid = parent.id;
 5103    // Value signed none mandatory
 5104    lib_fast::EncodeSigned(buf,parent.Value,false);
 5105    lib_fast::InsertPmap(buf,index,pmap);
 5106}
 5107
 5108// --- fasttest.I32None..FastDecode
 5109bool fasttest::I32None_FastDecode(algo::memptr& from, u64 pmap, FastState& state, fasttest::I32None& parent) {
 5110    bool ok = true;
 5111    // Value signed none mandatory
 5112    if (ok) {
 5113        ok = lib_fast::DecodeSigned(from,parent.Value,false);
 5114        if (!ok) {
 5115            state.error << "fasttest.I32None.Value: bad Signed" << eol;
 5116        }
 5117    }
 5118    (void)pmap;//only to avoid -Wunused-parameter
 5119    return ok;
 5120}
 5121
 5122// --- fasttest.I32None..FixEncode
 5123void fasttest::I32None_FixEncode(cstring& buf, fasttest::I32None& parent, char soh) {
 5124    buf << "1=" << parent.Value << soh;
 5125}
 5126
 5127// --- fasttest.I32NoneOpt.base.CopyOut
 5128// Copy fields out of row
 5129void fasttest::parent_CopyOut(fasttest::I32NoneOpt &row, fasttest::TemplateHeader &out) {
 5130    // length: field value is computed
 5131    // id: field value is computed
 5132    (void)row;//only to avoid -Wunused-parameter
 5133    (void)out;//only to avoid -Wunused-parameter
 5134}
 5135
 5136// --- fasttest.I32NoneOpt.Value.ReadStrptrMaybe
 5137inline static bool fasttest::Value_ReadStrptrMaybe(fasttest::I32NoneOpt &parent, algo::strptr in_str) {
 5138    bool retval = true;
 5139    i32 Value_tmp;
 5140    retval = i32_ReadStrptrMaybe(Value_tmp, in_str);
 5141    if (retval) {
 5142        Value_Set(parent, Value_tmp);
 5143    }
 5144    return retval;
 5145}
 5146
 5147// --- fasttest.I32NoneOpt.pmask_bitcurs.Next
 5148// proceed to next item
 5149void fasttest::I32NoneOpt_pmask_bitcurs_Next(I32NoneOpt_pmask_bitcurs &curs) {
 5150    ++curs.bit;
 5151    int index = curs.bit / 32;
 5152    int offset = curs.bit % 32;
 5153    for (; index < curs.n_elems; ++index, offset = 0) {
 5154        u64 rest = curs.elems[index] >> offset;
 5155        if (rest) {
 5156            offset += algo::u64_BitScanForward(rest);
 5157            break;
 5158        }
 5159    }
 5160    curs.bit = index * 32 + offset;
 5161}
 5162
 5163// --- fasttest.I32NoneOpt..ReadFieldMaybe
 5164bool fasttest::I32NoneOpt_ReadFieldMaybe(fasttest::I32NoneOpt& parent, algo::strptr field, algo::strptr strval) {
 5165    bool retval = true;
 5166    fasttest::FieldId field_id;
 5167    (void)value_SetStrptrMaybe(field_id,field);
 5168    switch(field_id) {
 5169        case fasttest_FieldId_base: {
 5170            retval = false;
 5171            break;
 5172        }
 5173        case fasttest_FieldId_length: {
 5174            retval = false;
 5175            break;
 5176        }
 5177        case fasttest_FieldId_id: {
 5178            retval = false;
 5179            break;
 5180        }
 5181        case fasttest_FieldId_pmask: {
 5182            retval = false;
 5183            break;
 5184        }
 5185        case fasttest_FieldId_Value: {
 5186            retval = Value_ReadStrptrMaybe(parent, strval);
 5187            if (retval) {
 5188                pmask_qSetBit(parent, 0);
 5189            }
 5190            break;
 5191        }
 5192        default: break;
 5193    }
 5194    if (!retval) {
 5195        algo_lib::AppendErrtext("attr",field);
 5196    }
 5197    return retval;
 5198}
 5199
 5200// --- fasttest.I32NoneOpt..ReadStrptrMaybe
 5201// Read fields of fasttest::I32NoneOpt from an ascii string.
 5202// The format of the string is an ssim Tuple
 5203bool fasttest::I32NoneOpt_ReadStrptrMaybe(fasttest::I32NoneOpt &parent, algo::strptr in_str) {
 5204    bool retval = true;
 5205    retval = algo::StripTypeTag(in_str, "fasttest.I32NoneOpt");
 5206    ind_beg(algo::Attr_curs, attr, in_str) {
 5207        retval = retval && I32NoneOpt_ReadFieldMaybe(parent, attr.name, attr.value);
 5208    }ind_end;
 5209    return retval;
 5210}
 5211
 5212// --- fasttest.I32NoneOpt..Print
 5213// print string representation of ROW to string STR
 5214// cfmt:fasttest.I32NoneOpt.String  printfmt:Tuple
 5215void fasttest::I32NoneOpt_Print(fasttest::I32NoneOpt& row, algo::cstring& str) {
 5216    algo::tempstr temp;
 5217    str << "fasttest.I32NoneOpt";
 5218
 5219    if (Value_PresentQ(row)) {
 5220        i32_Print(row.Value, temp);
 5221        PrintAttrSpaceReset(str,"Value", temp);
 5222    }
 5223}
 5224
 5225// --- fasttest.I32NoneOpt..FastEncode
 5226void fasttest::I32NoneOpt_FastEncode(algo::ByteAry& buf, FastState& state, fasttest::I32NoneOpt& parent) {
 5227    int index = ary_N(buf);
 5228    u64 pmap(0);
 5229    if (!tid_AssignedQ(state) || parent.id != state.tid) {
 5230        lib_fast::EncodeUnsigned(buf,parent.id,false);
 5231        lib_fast::SetPmapBit(pmap,0);
 5232    }
 5233    tid_SetAssigned(state);
 5234    state.tid = parent.id;
 5235    // Value signed none optional
 5236    if (Value_PresentQ(parent)) {
 5237        lib_fast::EncodeSigned(buf,parent.Value,true);
 5238    } else {
 5239        lib_fast::EncodeNull(buf);
 5240    }
 5241    lib_fast::InsertPmap(buf,index,pmap);
 5242}
 5243
 5244// --- fasttest.I32NoneOpt..FastDecode
 5245bool fasttest::I32NoneOpt_FastDecode(algo::memptr& from, u64 pmap, FastState& state, fasttest::I32NoneOpt& parent) {
 5246    bool ok = true;
 5247    // Value signed none optional
 5248    if (ok) {
 5249        bool prs = !lib_fast::DecodeNull(from);
 5250        if (prs) {
 5251            ok = lib_fast::DecodeSigned(from,parent.Value,true);
 5252            if (!ok) {
 5253                state.error << "fasttest.I32NoneOpt.Value: bad Signed" << eol;
 5254            }
 5255        }
 5256        pmask_qSetBitVal(parent,Value_Present_GetBit(parent),prs);
 5257    }
 5258    (void)pmap;//only to avoid -Wunused-parameter
 5259    return ok;
 5260}
 5261
 5262// --- fasttest.I32NoneOpt..FixEncode
 5263void fasttest::I32NoneOpt_FixEncode(cstring& buf, fasttest::I32NoneOpt& parent, char soh) {
 5264    if (Value_PresentQ(parent)) {
 5265        buf << "1=" << parent.Value << soh;
 5266    }
 5267}
 5268
 5269// --- fasttest.MsgPmap.base.CopyOut
 5270// Copy fields out of row
 5271void fasttest::parent_CopyOut(fasttest::MsgPmap &row, fasttest::TemplateHeader &out) {
 5272    // length: field value is computed
 5273    // id: field value is computed
 5274    (void)row;//only to avoid -Wunused-parameter
 5275    (void)out;//only to avoid -Wunused-parameter
 5276}
 5277
 5278// --- fasttest.MsgPmap.pmask_bitcurs.Next
 5279// proceed to next item
 5280void fasttest::MsgPmap_pmask_bitcurs_Next(MsgPmap_pmask_bitcurs &curs) {
 5281    ++curs.bit;
 5282    int index = curs.bit / 64;
 5283    int offset = curs.bit % 64;
 5284    for (; index < curs.n_elems; ++index, offset = 0) {
 5285        u64 rest = curs.elems[index] >> offset;
 5286        if (rest) {
 5287            offset += algo::u64_BitScanForward(rest);
 5288            break;
 5289        }
 5290    }
 5291    curs.bit = index * 64 + offset;
 5292}
 5293
 5294// --- fasttest.MsgPmap..ReadFieldMaybe
 5295bool fasttest::MsgPmap_ReadFieldMaybe(fasttest::MsgPmap& parent, algo::strptr field, algo::strptr strval) {
 5296    bool retval = true;
 5297    fasttest::FieldId field_id;
 5298    (void)value_SetStrptrMaybe(field_id,field);
 5299    switch(field_id) {
 5300        case fasttest_FieldId_base: {
 5301            retval = false;
 5302            break;
 5303        }
 5304        case fasttest_FieldId_length: {
 5305            retval = false;
 5306            break;
 5307        }
 5308        case fasttest_FieldId_id: {
 5309            retval = false;
 5310            break;
 5311        }
 5312        case fasttest_FieldId_pmask: {
 5313            retval = false;
 5314            break;
 5315        }
 5316        case fasttest_FieldId_Value1: {
 5317            retval = true;
 5318            if (retval) {
 5319                pmask_qSetBit(parent, 0);
 5320            }
 5321            break;
 5322        }
 5323        case fasttest_FieldId_Value2: {
 5324            retval = true;
 5325            if (retval) {
 5326                pmask_qSetBit(parent, 11);
 5327            }
 5328            break;
 5329        }
 5330        case fasttest_FieldId_Value3: {
 5331            retval = true;
 5332            if (retval) {
 5333                pmask_qSetBit(parent, 22);
 5334            }
 5335            break;
 5336        }
 5337        case fasttest_FieldId_Value4: {
 5338            retval = true;
 5339            if (retval) {
 5340                pmask_qSetBit(parent, 33);
 5341            }
 5342            break;
 5343        }
 5344        case fasttest_FieldId_Value5: {
 5345            retval = true;
 5346            if (retval) {
 5347                pmask_qSetBit(parent, 44);
 5348            }
 5349            break;
 5350        }
 5351        case fasttest_FieldId_Value6: {
 5352            retval = true;
 5353            if (retval) {
 5354                pmask_qSetBit(parent, 55);
 5355            }
 5356            break;
 5357        }
 5358        case fasttest_FieldId_Value7: {
 5359            retval = true;
 5360            if (retval) {
 5361                pmask_qSetBit(parent, 60);
 5362            }
 5363            break;
 5364        }
 5365        case fasttest_FieldId_Value8: {
 5366            retval = true;
 5367            if (retval) {
 5368                pmask_qSetBit(parent, 61);
 5369            }
 5370            break;
 5371        }
 5372        case fasttest_FieldId_Value9: {
 5373            retval = true;
 5374            if (retval) {
 5375                pmask_qSetBit(parent, 62);
 5376            }
 5377            break;
 5378        }
 5379        case fasttest_FieldId_Value10: {
 5380            retval = true;
 5381            if (retval) {
 5382                pmask_qSetBit(parent, 1);
 5383            }
 5384            break;
 5385        }
 5386        case fasttest_FieldId_Value11: {
 5387            retval = true;
 5388            if (retval) {
 5389                pmask_qSetBit(parent, 2);
 5390            }
 5391            break;
 5392        }
 5393        case fasttest_FieldId_Value12: {
 5394            retval = true;
 5395            if (retval) {
 5396                pmask_qSetBit(parent, 3);
 5397            }
 5398            break;
 5399        }
 5400        case fasttest_FieldId_Value13: {
 5401            retval = true;
 5402            if (retval) {
 5403                pmask_qSetBit(parent, 4);
 5404            }
 5405            break;
 5406        }
 5407        case fasttest_FieldId_Value14: {
 5408            retval = true;
 5409            if (retval) {
 5410                pmask_qSetBit(parent, 5);
 5411            }
 5412            break;
 5413        }
 5414        case fasttest_FieldId_Value15: {
 5415            retval = true;
 5416            if (retval) {
 5417                pmask_qSetBit(parent, 6);
 5418            }
 5419            break;
 5420        }
 5421        case fasttest_FieldId_Value16: {
 5422            retval = true;
 5423            if (retval) {
 5424                pmask_qSetBit(parent, 7);
 5425            }
 5426            break;
 5427        }
 5428        case fasttest_FieldId_Value17: {
 5429            retval = true;
 5430            if (retval) {
 5431                pmask_qSetBit(parent, 8);
 5432            }
 5433            break;
 5434        }
 5435        case fasttest_FieldId_Value18: {
 5436            retval = true;
 5437            if (retval) {
 5438                pmask_qSetBit(parent, 9);
 5439            }
 5440            break;
 5441        }
 5442        case fasttest_FieldId_Value19: {
 5443            retval = true;
 5444            if (retval) {
 5445                pmask_qSetBit(parent, 10);
 5446            }
 5447            break;
 5448        }
 5449        case fasttest_FieldId_Value20: {
 5450            retval = true;
 5451            if (retval) {
 5452                pmask_qSetBit(parent, 12);
 5453            }
 5454            break;
 5455        }
 5456        case fasttest_FieldId_Value21: {
 5457            retval = true;
 5458            if (retval) {
 5459                pmask_qSetBit(parent, 13);
 5460            }
 5461            break;
 5462        }
 5463        case fasttest_FieldId_Value22: {
 5464            retval = true;
 5465            if (retval) {
 5466                pmask_qSetBit(parent, 14);
 5467            }
 5468            break;
 5469        }
 5470        case fasttest_FieldId_Value23: {
 5471            retval = true;
 5472            if (retval) {
 5473                pmask_qSetBit(parent, 15);
 5474            }
 5475            break;
 5476        }
 5477        case fasttest_FieldId_Value24: {
 5478            retval = true;
 5479            if (retval) {
 5480                pmask_qSetBit(parent, 16);
 5481            }
 5482            break;
 5483        }
 5484        case fasttest_FieldId_Value25: {
 5485            retval = true;
 5486            if (retval) {
 5487                pmask_qSetBit(parent, 17);
 5488            }
 5489            break;
 5490        }
 5491        case fasttest_FieldId_Value26: {
 5492            retval = true;
 5493            if (retval) {
 5494                pmask_qSetBit(parent, 18);
 5495            }
 5496            break;
 5497        }
 5498        case fasttest_FieldId_Value27: {
 5499            retval = true;
 5500            if (retval) {
 5501                pmask_qSetBit(parent, 19);
 5502            }
 5503            break;
 5504        }
 5505        case fasttest_FieldId_Value28: {
 5506            retval = true;
 5507            if (retval) {
 5508                pmask_qSetBit(parent, 20);
 5509            }
 5510            break;
 5511        }
 5512        case fasttest_FieldId_Value29: {
 5513            retval = true;
 5514            if (retval) {
 5515                pmask_qSetBit(parent, 21);
 5516            }
 5517            break;
 5518        }
 5519        case fasttest_FieldId_Value30: {
 5520            retval = true;
 5521            if (retval) {
 5522                pmask_qSetBit(parent, 23);
 5523            }
 5524            break;
 5525        }
 5526        case fasttest_FieldId_Value31: {
 5527            retval = true;
 5528            if (retval) {
 5529                pmask_qSetBit(parent, 24);
 5530            }
 5531            break;
 5532        }
 5533        case fasttest_FieldId_Value32: {
 5534            retval = true;
 5535            if (retval) {
 5536                pmask_qSetBit(parent, 25);
 5537            }
 5538            break;
 5539        }
 5540        case fasttest_FieldId_Value33: {
 5541            retval = true;
 5542            if (retval) {
 5543                pmask_qSetBit(parent, 26);
 5544            }
 5545            break;
 5546        }
 5547        case fasttest_FieldId_Value34: {
 5548            retval = true;
 5549            if (retval) {
 5550                pmask_qSetBit(parent, 27);
 5551            }
 5552            break;
 5553        }
 5554        case fasttest_FieldId_Value35: {
 5555            retval = true;
 5556            if (retval) {
 5557                pmask_qSetBit(parent, 28);
 5558            }
 5559            break;
 5560        }
 5561        case fasttest_FieldId_Value36: {
 5562            retval = true;
 5563            if (retval) {
 5564                pmask_qSetBit(parent, 29);
 5565            }
 5566            break;
 5567        }
 5568        case fasttest_FieldId_Value37: {
 5569            retval = true;
 5570            if (retval) {
 5571                pmask_qSetBit(parent, 30);
 5572            }
 5573            break;
 5574        }
 5575        case fasttest_FieldId_Value38: {
 5576            retval = true;
 5577            if (retval) {
 5578                pmask_qSetBit(parent, 31);
 5579            }
 5580            break;
 5581        }
 5582        case fasttest_FieldId_Value39: {
 5583            retval = true;
 5584            if (retval) {
 5585                pmask_qSetBit(parent, 32);
 5586            }
 5587            break;
 5588        }
 5589        case fasttest_FieldId_Value40: {
 5590            retval = true;
 5591            if (retval) {
 5592                pmask_qSetBit(parent, 34);
 5593            }
 5594            break;
 5595        }
 5596        case fasttest_FieldId_Value41: {
 5597            retval = true;
 5598            if (retval) {
 5599                pmask_qSetBit(parent, 35);
 5600            }
 5601            break;
 5602        }
 5603        case fasttest_FieldId_Value42: {
 5604            retval = true;
 5605            if (retval) {
 5606                pmask_qSetBit(parent, 36);
 5607            }
 5608            break;
 5609        }
 5610        case fasttest_FieldId_Value43: {
 5611            retval = true;
 5612            if (retval) {
 5613                pmask_qSetBit(parent, 37);
 5614            }
 5615            break;
 5616        }
 5617        case fasttest_FieldId_Value44: {
 5618            retval = true;
 5619            if (retval) {
 5620                pmask_qSetBit(parent, 38);
 5621            }
 5622            break;
 5623        }
 5624        case fasttest_FieldId_Value45: {
 5625            retval = true;
 5626            if (retval) {
 5627                pmask_qSetBit(parent, 39);
 5628            }
 5629            break;
 5630        }
 5631        case fasttest_FieldId_Value46: {
 5632            retval = true;
 5633            if (retval) {
 5634                pmask_qSetBit(parent, 40);
 5635            }
 5636            break;
 5637        }
 5638        case fasttest_FieldId_Value47: {
 5639            retval = true;
 5640            if (retval) {
 5641                pmask_qSetBit(parent, 41);
 5642            }
 5643            break;
 5644        }
 5645        case fasttest_FieldId_Value48: {
 5646            retval = true;
 5647            if (retval) {
 5648                pmask_qSetBit(parent, 42);
 5649            }
 5650            break;
 5651        }
 5652        case fasttest_FieldId_Value49: {
 5653            retval = true;
 5654            if (retval) {
 5655                pmask_qSetBit(parent, 43);
 5656            }
 5657            break;
 5658        }
 5659        case fasttest_FieldId_Value50: {
 5660            retval = true;
 5661            if (retval) {
 5662                pmask_qSetBit(parent, 45);
 5663            }
 5664            break;
 5665        }
 5666        case fasttest_FieldId_Value51: {
 5667            retval = true;
 5668            if (retval) {
 5669                pmask_qSetBit(parent, 46);
 5670            }
 5671            break;
 5672        }
 5673        case fasttest_FieldId_Value52: {
 5674            retval = true;
 5675            if (retval) {
 5676                pmask_qSetBit(parent, 47);
 5677            }
 5678            break;
 5679        }
 5680        case fasttest_FieldId_Value53: {
 5681            retval = true;
 5682            if (retval) {
 5683                pmask_qSetBit(parent, 48);
 5684            }
 5685            break;
 5686        }
 5687        case fasttest_FieldId_Value54: {
 5688            retval = true;
 5689            if (retval) {
 5690                pmask_qSetBit(parent, 49);
 5691            }
 5692            break;
 5693        }
 5694        case fasttest_FieldId_Value55: {
 5695            retval = true;
 5696            if (retval) {
 5697                pmask_qSetBit(parent, 50);
 5698            }
 5699            break;
 5700        }
 5701        case fasttest_FieldId_Value56: {
 5702            retval = true;
 5703            if (retval) {
 5704                pmask_qSetBit(parent, 51);
 5705            }
 5706            break;
 5707        }
 5708        case fasttest_FieldId_Value57: {
 5709            retval = true;
 5710            if (retval) {
 5711                pmask_qSetBit(parent, 52);
 5712            }
 5713            break;
 5714        }
 5715        case fasttest_FieldId_Value58: {
 5716            retval = true;
 5717            if (retval) {
 5718                pmask_qSetBit(parent, 53);
 5719            }
 5720            break;
 5721        }
 5722        case fasttest_FieldId_Value59: {
 5723            retval = true;
 5724            if (retval) {
 5725                pmask_qSetBit(parent, 54);
 5726            }
 5727            break;
 5728        }
 5729        case fasttest_FieldId_Value60: {
 5730            retval = true;
 5731            if (retval) {
 5732                pmask_qSetBit(parent, 56);
 5733            }
 5734            break;
 5735        }
 5736        case fasttest_FieldId_Value61: {
 5737            retval = true;
 5738            if (retval) {
 5739                pmask_qSetBit(parent, 57);
 5740            }
 5741            break;
 5742        }
 5743        case fasttest_FieldId_Value62: {
 5744            retval = true;
 5745            if (retval) {
 5746                pmask_qSetBit(parent, 58);
 5747            }
 5748            break;
 5749        }
 5750        case fasttest_FieldId_Value63: {
 5751            retval = true;
 5752            if (retval) {
 5753                pmask_qSetBit(parent, 59);
 5754            }
 5755            break;
 5756        }
 5757        default: break;
 5758    }
 5759    if (!retval) {
 5760        algo_lib::AppendErrtext("attr",field);
 5761    }
 5762    (void)strval;//only to avoid -Wunused-parameter
 5763    return retval;
 5764}
 5765
 5766// --- fasttest.MsgPmap..ReadStrptrMaybe
 5767// Read fields of fasttest::MsgPmap from an ascii string.
 5768// The format of the string is an ssim Tuple
 5769bool fasttest::MsgPmap_ReadStrptrMaybe(fasttest::MsgPmap &parent, algo::strptr in_str) {
 5770    bool retval = true;
 5771    retval = algo::StripTypeTag(in_str, "fasttest.MsgPmap");
 5772    ind_beg(algo::Attr_curs, attr, in_str) {
 5773        retval = retval && MsgPmap_ReadFieldMaybe(parent, attr.name, attr.value);
 5774    }ind_end;
 5775    return retval;
 5776}
 5777
 5778// --- fasttest.MsgPmap..Init
 5779// Set all fields to initial values.
 5780void fasttest::MsgPmap_Init(fasttest::MsgPmap& parent) {
 5781    parent.length = u32(ssizeof(parent) + (0));
 5782    parent.id = u32(151);
 5783    parent.pmask = u64(0);
 5784}
 5785
 5786// --- fasttest.MsgPmap..Print
 5787// print string representation of ROW to string STR
 5788// cfmt:fasttest.MsgPmap.String  printfmt:Tuple
 5789void fasttest::MsgPmap_Print(fasttest::MsgPmap& row, algo::cstring& str) {
 5790    algo::tempstr temp;
 5791    str << "fasttest.MsgPmap";
 5792
 5793    if (Value1_PresentQ(row)) {
 5794        u32_Print(Value1_Get(row), temp);
 5795        PrintAttrSpaceReset(str,"Value1", temp);
 5796    }
 5797
 5798    if (Value2_PresentQ(row)) {
 5799        u32_Print(Value2_Get(row), temp);
 5800        PrintAttrSpaceReset(str,"Value2", temp);
 5801    }
 5802
 5803    if (Value3_PresentQ(row)) {
 5804        u32_Print(Value3_Get(row), temp);
 5805        PrintAttrSpaceReset(str,"Value3", temp);
 5806    }
 5807
 5808    if (Value4_PresentQ(row)) {
 5809        u32_Print(Value4_Get(row), temp);
 5810        PrintAttrSpaceReset(str,"Value4", temp);
 5811    }
 5812
 5813    if (Value5_PresentQ(row)) {
 5814        u32_Print(Value5_Get(row), temp);
 5815        PrintAttrSpaceReset(str,"Value5", temp);
 5816    }
 5817
 5818    if (Value6_PresentQ(row)) {
 5819        u32_Print(Value6_Get(row), temp);
 5820        PrintAttrSpaceReset(str,"Value6", temp);
 5821    }
 5822
 5823    if (Value7_PresentQ(row)) {
 5824        u32_Print(Value7_Get(row), temp);
 5825        PrintAttrSpaceReset(str,"Value7", temp);
 5826    }
 5827
 5828    if (Value8_PresentQ(row)) {
 5829        u32_Print(Value8_Get(row), temp);
 5830        PrintAttrSpaceReset(str,"Value8", temp);
 5831    }
 5832
 5833    if (Value9_PresentQ(row)) {
 5834        u32_Print(Value9_Get(row), temp);
 5835        PrintAttrSpaceReset(str,"Value9", temp);
 5836    }
 5837
 5838    if (Value10_PresentQ(row)) {
 5839        u32_Print(Value10_Get(row), temp);
 5840        PrintAttrSpaceReset(str,"Value10", temp);
 5841    }
 5842
 5843    if (Value11_PresentQ(row)) {
 5844        u32_Print(Value11_Get(row), temp);
 5845        PrintAttrSpaceReset(str,"Value11", temp);
 5846    }
 5847
 5848    if (Value12_PresentQ(row)) {
 5849        u32_Print(Value12_Get(row), temp);
 5850        PrintAttrSpaceReset(str,"Value12", temp);
 5851    }
 5852
 5853    if (Value13_PresentQ(row)) {
 5854        u32_Print(Value13_Get(row), temp);
 5855        PrintAttrSpaceReset(str,"Value13", temp);
 5856    }
 5857
 5858    if (Value14_PresentQ(row)) {
 5859        u32_Print(Value14_Get(row), temp);
 5860        PrintAttrSpaceReset(str,"Value14", temp);
 5861    }
 5862
 5863    if (Value15_PresentQ(row)) {
 5864        u32_Print(Value15_Get(row), temp);
 5865        PrintAttrSpaceReset(str,"Value15", temp);
 5866    }
 5867
 5868    if (Value16_PresentQ(row)) {
 5869        u32_Print(Value16_Get(row), temp);
 5870        PrintAttrSpaceReset(str,"Value16", temp);
 5871    }
 5872
 5873    if (Value17_PresentQ(row)) {
 5874        u32_Print(Value17_Get(row), temp);
 5875        PrintAttrSpaceReset(str,"Value17", temp);
 5876    }
 5877
 5878    if (Value18_PresentQ(row)) {
 5879        u32_Print(Value18_Get(row), temp);
 5880        PrintAttrSpaceReset(str,"Value18", temp);
 5881    }
 5882
 5883    if (Value19_PresentQ(row)) {
 5884        u32_Print(Value19_Get(row), temp);
 5885        PrintAttrSpaceReset(str,"Value19", temp);
 5886    }
 5887
 5888    if (Value20_PresentQ(row)) {
 5889        u32_Print(Value20_Get(row), temp);
 5890        PrintAttrSpaceReset(str,"Value20", temp);
 5891    }
 5892
 5893    if (Value21_PresentQ(row)) {
 5894        u32_Print(Value21_Get(row), temp);
 5895        PrintAttrSpaceReset(str,"Value21", temp);
 5896    }
 5897
 5898    if (Value22_PresentQ(row)) {
 5899        u32_Print(Value22_Get(row), temp);
 5900        PrintAttrSpaceReset(str,"Value22", temp);
 5901    }
 5902
 5903    if (Value23_PresentQ(row)) {
 5904        u32_Print(Value23_Get(row), temp);
 5905        PrintAttrSpaceReset(str,"Value23", temp);
 5906    }
 5907
 5908    if (Value24_PresentQ(row)) {
 5909        u32_Print(Value24_Get(row), temp);
 5910        PrintAttrSpaceReset(str,"Value24", temp);
 5911    }
 5912
 5913    if (Value25_PresentQ(row)) {
 5914        u32_Print(Value25_Get(row), temp);
 5915        PrintAttrSpaceReset(str,"Value25", temp);
 5916    }
 5917
 5918    if (Value26_PresentQ(row)) {
 5919        u32_Print(Value26_Get(row), temp);
 5920        PrintAttrSpaceReset(str,"Value26", temp);
 5921    }
 5922
 5923    if (Value27_PresentQ(row)) {
 5924        u32_Print(Value27_Get(row), temp);
 5925        PrintAttrSpaceReset(str,"Value27", temp);
 5926    }
 5927
 5928    if (Value28_PresentQ(row)) {
 5929        u32_Print(Value28_Get(row), temp);
 5930        PrintAttrSpaceReset(str,"Value28", temp);
 5931    }
 5932
 5933    if (Value29_PresentQ(row)) {
 5934        u32_Print(Value29_Get(row), temp);
 5935        PrintAttrSpaceReset(str,"Value29", temp);
 5936    }
 5937
 5938    if (Value30_PresentQ(row)) {
 5939        u32_Print(Value30_Get(row), temp);
 5940        PrintAttrSpaceReset(str,"Value30", temp);
 5941    }
 5942
 5943    if (Value31_PresentQ(row)) {
 5944        u32_Print(Value31_Get(row), temp);
 5945        PrintAttrSpaceReset(str,"Value31", temp);
 5946    }
 5947
 5948    if (Value32_PresentQ(row)) {
 5949        u32_Print(Value32_Get(row), temp);
 5950        PrintAttrSpaceReset(str,"Value32", temp);
 5951    }
 5952
 5953    if (Value33_PresentQ(row)) {
 5954        u32_Print(Value33_Get(row), temp);
 5955        PrintAttrSpaceReset(str,"Value33", temp);
 5956    }
 5957
 5958    if (Value34_PresentQ(row)) {
 5959        u32_Print(Value34_Get(row), temp);
 5960        PrintAttrSpaceReset(str,"Value34", temp);
 5961    }
 5962
 5963    if (Value35_PresentQ(row)) {
 5964        u32_Print(Value35_Get(row), temp);
 5965        PrintAttrSpaceReset(str,"Value35", temp);
 5966    }
 5967
 5968    if (Value36_PresentQ(row)) {
 5969        u32_Print(Value36_Get(row), temp);
 5970        PrintAttrSpaceReset(str,"Value36", temp);
 5971    }
 5972
 5973    if (Value37_PresentQ(row)) {
 5974        u32_Print(Value37_Get(row), temp);
 5975        PrintAttrSpaceReset(str,"Value37", temp);
 5976    }
 5977
 5978    if (Value38_PresentQ(row)) {
 5979        u32_Print(Value38_Get(row), temp);
 5980        PrintAttrSpaceReset(str,"Value38", temp);
 5981    }
 5982
 5983    if (Value39_PresentQ(row)) {
 5984        u32_Print(Value39_Get(row), temp);
 5985        PrintAttrSpaceReset(str,"Value39", temp);
 5986    }
 5987
 5988    if (Value40_PresentQ(row)) {
 5989        u32_Print(Value40_Get(row), temp);
 5990        PrintAttrSpaceReset(str,"Value40", temp);
 5991    }
 5992
 5993    if (Value41_PresentQ(row)) {
 5994        u32_Print(Value41_Get(row), temp);
 5995        PrintAttrSpaceReset(str,"Value41", temp);
 5996    }
 5997
 5998    if (Value42_PresentQ(row)) {
 5999        u32_Print(Value42_Get(row), temp);
 6000        PrintAttrSpaceReset(str,"Value42", temp);
 6001    }
 6002
 6003    if (Value43_PresentQ(row)) {
 6004        u32_Print(Value43_Get(row), temp);
 6005        PrintAttrSpaceReset(str,"Value43", temp);
 6006    }
 6007
 6008    if (Value44_PresentQ(row)) {
 6009        u32_Print(Value44_Get(row), temp);
 6010        PrintAttrSpaceReset(str,"Value44", temp);
 6011    }
 6012
 6013    if (Value45_PresentQ(row)) {
 6014        u32_Print(Value45_Get(row), temp);
 6015        PrintAttrSpaceReset(str,"Value45", temp);
 6016    }
 6017
 6018    if (Value46_PresentQ(row)) {
 6019        u32_Print(Value46_Get(row), temp);
 6020        PrintAttrSpaceReset(str,"Value46", temp);
 6021    }
 6022
 6023    if (Value47_PresentQ(row)) {
 6024        u32_Print(Value47_Get(row), temp);
 6025        PrintAttrSpaceReset(str,"Value47", temp);
 6026    }
 6027
 6028    if (Value48_PresentQ(row)) {
 6029        u32_Print(Value48_Get(row), temp);
 6030        PrintAttrSpaceReset(str,"Value48", temp);
 6031    }
 6032
 6033    if (Value49_PresentQ(row)) {
 6034        u32_Print(Value49_Get(row), temp);
 6035        PrintAttrSpaceReset(str,"Value49", temp);
 6036    }
 6037
 6038    if (Value50_PresentQ(row)) {
 6039        u32_Print(Value50_Get(row), temp);
 6040        PrintAttrSpaceReset(str,"Value50", temp);
 6041    }
 6042
 6043    if (Value51_PresentQ(row)) {
 6044        u32_Print(Value51_Get(row), temp);
 6045        PrintAttrSpaceReset(str,"Value51", temp);
 6046    }
 6047
 6048    if (Value52_PresentQ(row)) {
 6049        u32_Print(Value52_Get(row), temp);
 6050        PrintAttrSpaceReset(str,"Value52", temp);
 6051    }
 6052
 6053    if (Value53_PresentQ(row)) {
 6054        u32_Print(Value53_Get(row), temp);
 6055        PrintAttrSpaceReset(str,"Value53", temp);
 6056    }
 6057
 6058    if (Value54_PresentQ(row)) {
 6059        u32_Print(Value54_Get(row), temp);
 6060        PrintAttrSpaceReset(str,"Value54", temp);
 6061    }
 6062
 6063    if (Value55_PresentQ(row)) {
 6064        u32_Print(Value55_Get(row), temp);
 6065        PrintAttrSpaceReset(str,"Value55", temp);
 6066    }
 6067
 6068    if (Value56_PresentQ(row)) {
 6069        u32_Print(Value56_Get(row), temp);
 6070        PrintAttrSpaceReset(str,"Value56", temp);
 6071    }
 6072
 6073    if (Value57_PresentQ(row)) {
 6074        u32_Print(Value57_Get(row), temp);
 6075        PrintAttrSpaceReset(str,"Value57", temp);
 6076    }
 6077
 6078    if (Value58_PresentQ(row)) {
 6079        u32_Print(Value58_Get(row), temp);
 6080        PrintAttrSpaceReset(str,"Value58", temp);
 6081    }
 6082
 6083    if (Value59_PresentQ(row)) {
 6084        u32_Print(Value59_Get(row), temp);
 6085        PrintAttrSpaceReset(str,"Value59", temp);
 6086    }
 6087
 6088    if (Value60_PresentQ(row)) {
 6089        u32_Print(Value60_Get(row), temp);
 6090        PrintAttrSpaceReset(str,"Value60", temp);
 6091    }
 6092
 6093    if (Value61_PresentQ(row)) {
 6094        u32_Print(Value61_Get(row), temp);
 6095        PrintAttrSpaceReset(str,"Value61", temp);
 6096    }
 6097
 6098    if (Value62_PresentQ(row)) {
 6099        u32_Print(Value62_Get(row), temp);
 6100        PrintAttrSpaceReset(str,"Value62", temp);
 6101    }
 6102
 6103    if (Value63_PresentQ(row)) {
 6104        u32_Print(Value63_Get(row), temp);
 6105        PrintAttrSpaceReset(str,"Value63", temp);
 6106    }
 6107}
 6108
 6109// --- fasttest.MsgPmap..FastEncode
 6110void fasttest::MsgPmap_FastEncode(algo::ByteAry& buf, FastState& state, fasttest::MsgPmap& parent) {
 6111    int index = ary_N(buf);
 6112    u64 pmap(0);
 6113    if (!tid_AssignedQ(state) || parent.id != state.tid) {
 6114        lib_fast::EncodeUnsigned(buf,parent.id,false);
 6115        lib_fast::SetPmapBit(pmap,0);
 6116    }
 6117    tid_SetAssigned(state);
 6118    state.tid = parent.id;
 6119    // Value1 unsigned constant optional
 6120    if (Value1_PresentQ(parent)) {
 6121        lib_fast::SetPmapBit(pmap,1);
 6122    }
 6123    // Value2 unsigned constant optional
 6124    if (Value2_PresentQ(parent)) {
 6125        lib_fast::SetPmapBit(pmap,2);
 6126    }
 6127    // Value3 unsigned constant optional
 6128    if (Value3_PresentQ(parent)) {
 6129        lib_fast::SetPmapBit(pmap,3);
 6130    }
 6131    // Value4 unsigned constant optional
 6132    if (Value4_PresentQ(parent)) {
 6133        lib_fast::SetPmapBit(pmap,4);
 6134    }
 6135    // Value5 unsigned constant optional
 6136    if (Value5_PresentQ(parent)) {
 6137        lib_fast::SetPmapBit(pmap,5);
 6138    }
 6139    // Value6 unsigned constant optional
 6140    if (Value6_PresentQ(parent)) {
 6141        lib_fast::SetPmapBit(pmap,6);
 6142    }
 6143    // Value7 unsigned constant optional
 6144    if (Value7_PresentQ(parent)) {
 6145        lib_fast::SetPmapBit(pmap,7);
 6146    }
 6147    // Value8 unsigned constant optional
 6148    if (Value8_PresentQ(parent)) {
 6149        lib_fast::SetPmapBit(pmap,8);
 6150    }
 6151    // Value9 unsigned constant optional
 6152    if (Value9_PresentQ(parent)) {
 6153        lib_fast::SetPmapBit(pmap,9);
 6154    }
 6155    // Value10 unsigned constant optional
 6156    if (Value10_PresentQ(parent)) {
 6157        lib_fast::SetPmapBit(pmap,10);
 6158    }
 6159    // Value11 unsigned constant optional
 6160    if (Value11_PresentQ(parent)) {
 6161        lib_fast::SetPmapBit(pmap,11);
 6162    }
 6163    // Value12 unsigned constant optional
 6164    if (Value12_PresentQ(parent)) {
 6165        lib_fast::SetPmapBit(pmap,12);
 6166    }
 6167    // Value13 unsigned constant optional
 6168    if (Value13_PresentQ(parent)) {
 6169        lib_fast::SetPmapBit(pmap,13);
 6170    }
 6171    // Value14 unsigned constant optional
 6172    if (Value14_PresentQ(parent)) {
 6173        lib_fast::SetPmapBit(pmap,14);
 6174    }
 6175    // Value15 unsigned constant optional
 6176    if (Value15_PresentQ(parent)) {
 6177        lib_fast::SetPmapBit(pmap,15);
 6178    }
 6179    // Value16 unsigned constant optional
 6180    if (Value16_PresentQ(parent)) {
 6181        lib_fast::SetPmapBit(pmap,16);
 6182    }
 6183    // Value17 unsigned constant optional
 6184    if (Value17_PresentQ(parent)) {
 6185        lib_fast::SetPmapBit(pmap,17);
 6186    }
 6187    // Value18 unsigned constant optional
 6188    if (Value18_PresentQ(parent)) {
 6189        lib_fast::SetPmapBit(pmap,18);
 6190    }
 6191    // Value19 unsigned constant optional
 6192    if (Value19_PresentQ(parent)) {
 6193        lib_fast::SetPmapBit(pmap,19);
 6194    }
 6195    // Value20 unsigned constant optional
 6196    if (Value20_PresentQ(parent)) {
 6197        lib_fast::SetPmapBit(pmap,20);
 6198    }
 6199    // Value21 unsigned constant optional
 6200    if (Value21_PresentQ(parent)) {
 6201        lib_fast::SetPmapBit(pmap,21);
 6202    }
 6203    // Value22 unsigned constant optional
 6204    if (Value22_PresentQ(parent)) {
 6205        lib_fast::SetPmapBit(pmap,22);
 6206    }
 6207    // Value23 unsigned constant optional
 6208    if (Value23_PresentQ(parent)) {
 6209        lib_fast::SetPmapBit(pmap,23);
 6210    }
 6211    // Value24 unsigned constant optional
 6212    if (Value24_PresentQ(parent)) {
 6213        lib_fast::SetPmapBit(pmap,24);
 6214    }
 6215    // Value25 unsigned constant optional
 6216    if (Value25_PresentQ(parent)) {
 6217        lib_fast::SetPmapBit(pmap,25);
 6218    }
 6219    // Value26 unsigned constant optional
 6220    if (Value26_PresentQ(parent)) {
 6221        lib_fast::SetPmapBit(pmap,26);
 6222    }
 6223    // Value27 unsigned constant optional
 6224    if (Value27_PresentQ(parent)) {
 6225        lib_fast::SetPmapBit(pmap,27);
 6226    }
 6227    // Value28 unsigned constant optional
 6228    if (Value28_PresentQ(parent)) {
 6229        lib_fast::SetPmapBit(pmap,28);
 6230    }
 6231    // Value29 unsigned constant optional
 6232    if (Value29_PresentQ(parent)) {
 6233        lib_fast::SetPmapBit(pmap,29);
 6234    }
 6235    // Value30 unsigned constant optional
 6236    if (Value30_PresentQ(parent)) {
 6237        lib_fast::SetPmapBit(pmap,30);
 6238    }
 6239    // Value31 unsigned constant optional
 6240    if (Value31_PresentQ(parent)) {
 6241        lib_fast::SetPmapBit(pmap,31);
 6242    }
 6243    // Value32 unsigned constant optional
 6244    if (Value32_PresentQ(parent)) {
 6245        lib_fast::SetPmapBit(pmap,32);
 6246    }
 6247    // Value33 unsigned constant optional
 6248    if (Value33_PresentQ(parent)) {
 6249        lib_fast::SetPmapBit(pmap,33);
 6250    }
 6251    // Value34 unsigned constant optional
 6252    if (Value34_PresentQ(parent)) {
 6253        lib_fast::SetPmapBit(pmap,34);
 6254    }
 6255    // Value35 unsigned constant optional
 6256    if (Value35_PresentQ(parent)) {
 6257        lib_fast::SetPmapBit(pmap,35);
 6258    }
 6259    // Value36 unsigned constant optional
 6260    if (Value36_PresentQ(parent)) {
 6261        lib_fast::SetPmapBit(pmap,36);
 6262    }
 6263    // Value37 unsigned constant optional
 6264    if (Value37_PresentQ(parent)) {
 6265        lib_fast::SetPmapBit(pmap,37);
 6266    }
 6267    // Value38 unsigned constant optional
 6268    if (Value38_PresentQ(parent)) {
 6269        lib_fast::SetPmapBit(pmap,38);
 6270    }
 6271    // Value39 unsigned constant optional
 6272    if (Value39_PresentQ(parent)) {
 6273        lib_fast::SetPmapBit(pmap,39);
 6274    }
 6275    // Value40 unsigned constant optional
 6276    if (Value40_PresentQ(parent)) {
 6277        lib_fast::SetPmapBit(pmap,40);
 6278    }
 6279    // Value41 unsigned constant optional
 6280    if (Value41_PresentQ(parent)) {
 6281        lib_fast::SetPmapBit(pmap,41);
 6282    }
 6283    // Value42 unsigned constant optional
 6284    if (Value42_PresentQ(parent)) {
 6285        lib_fast::SetPmapBit(pmap,42);
 6286    }
 6287    // Value43 unsigned constant optional
 6288    if (Value43_PresentQ(parent)) {
 6289        lib_fast::SetPmapBit(pmap,43);
 6290    }
 6291    // Value44 unsigned constant optional
 6292    if (Value44_PresentQ(parent)) {
 6293        lib_fast::SetPmapBit(pmap,44);
 6294    }
 6295    // Value45 unsigned constant optional
 6296    if (Value45_PresentQ(parent)) {
 6297        lib_fast::SetPmapBit(pmap,45);
 6298    }
 6299    // Value46 unsigned constant optional
 6300    if (Value46_PresentQ(parent)) {
 6301        lib_fast::SetPmapBit(pmap,46);
 6302    }
 6303    // Value47 unsigned constant optional
 6304    if (Value47_PresentQ(parent)) {
 6305        lib_fast::SetPmapBit(pmap,47);
 6306    }
 6307    // Value48 unsigned constant optional
 6308    if (Value48_PresentQ(parent)) {
 6309        lib_fast::SetPmapBit(pmap,48);
 6310    }
 6311    // Value49 unsigned constant optional
 6312    if (Value49_PresentQ(parent)) {
 6313        lib_fast::SetPmapBit(pmap,49);
 6314    }
 6315    // Value50 unsigned constant optional
 6316    if (Value50_PresentQ(parent)) {
 6317        lib_fast::SetPmapBit(pmap,50);
 6318    }
 6319    // Value51 unsigned constant optional
 6320    if (Value51_PresentQ(parent)) {
 6321        lib_fast::SetPmapBit(pmap,51);
 6322    }
 6323    // Value52 unsigned constant optional
 6324    if (Value52_PresentQ(parent)) {
 6325        lib_fast::SetPmapBit(pmap,52);
 6326    }
 6327    // Value53 unsigned constant optional
 6328    if (Value53_PresentQ(parent)) {
 6329        lib_fast::SetPmapBit(pmap,53);
 6330    }
 6331    // Value54 unsigned constant optional
 6332    if (Value54_PresentQ(parent)) {
 6333        lib_fast::SetPmapBit(pmap,54);
 6334    }
 6335    // Value55 unsigned constant optional
 6336    if (Value55_PresentQ(parent)) {
 6337        lib_fast::SetPmapBit(pmap,55);
 6338    }
 6339    // Value56 unsigned constant optional
 6340    if (Value56_PresentQ(parent)) {
 6341        lib_fast::SetPmapBit(pmap,56);
 6342    }
 6343    // Value57 unsigned constant optional
 6344    if (Value57_PresentQ(parent)) {
 6345        lib_fast::SetPmapBit(pmap,57);
 6346    }
 6347    // Value58 unsigned constant optional
 6348    if (Value58_PresentQ(parent)) {
 6349        lib_fast::SetPmapBit(pmap,58);
 6350    }
 6351    // Value59 unsigned constant optional
 6352    if (Value59_PresentQ(parent)) {
 6353        lib_fast::SetPmapBit(pmap,59);
 6354    }
 6355    // Value60 unsigned constant optional
 6356    if (Value60_PresentQ(parent)) {
 6357        lib_fast::SetPmapBit(pmap,60);
 6358    }
 6359    // Value61 unsigned constant optional
 6360    if (Value61_PresentQ(parent)) {
 6361        lib_fast::SetPmapBit(pmap,61);
 6362    }
 6363    // Value62 unsigned constant optional
 6364    if (Value62_PresentQ(parent)) {
 6365        lib_fast::SetPmapBit(pmap,62);
 6366    }
 6367    // Value63 unsigned constant optional
 6368    if (Value63_PresentQ(parent)) {
 6369        lib_fast::SetPmapBit(pmap,63);
 6370    }
 6371    lib_fast::InsertPmap(buf,index,pmap);
 6372}
 6373
 6374// --- fasttest.MsgPmap..FastDecode
 6375bool fasttest::MsgPmap_FastDecode(algo::memptr& from, u64 pmap, FastState& state, fasttest::MsgPmap& parent) {
 6376    bool ok = true;
 6377    // Value1 unsigned constant optional
 6378    if (ok) {
 6379        bool prs = lib_fast::GetPmapBit(pmap,1);
 6380        pmask_qSetBitVal(parent,Value1_Present_GetBit(parent),prs);
 6381    }
 6382    // Value2 unsigned constant optional
 6383    if (ok) {
 6384        bool prs = lib_fast::GetPmapBit(pmap,2);
 6385        pmask_qSetBitVal(parent,Value2_Present_GetBit(parent),prs);
 6386    }
 6387    // Value3 unsigned constant optional
 6388    if (ok) {
 6389        bool prs = lib_fast::GetPmapBit(pmap,3);
 6390        pmask_qSetBitVal(parent,Value3_Present_GetBit(parent),prs);
 6391    }
 6392    // Value4 unsigned constant optional
 6393    if (ok) {
 6394        bool prs = lib_fast::GetPmapBit(pmap,4);
 6395        pmask_qSetBitVal(parent,Value4_Present_GetBit(parent),prs);
 6396    }
 6397    // Value5 unsigned constant optional
 6398    if (ok) {
 6399        bool prs = lib_fast::GetPmapBit(pmap,5);
 6400        pmask_qSetBitVal(parent,Value5_Present_GetBit(parent),prs);
 6401    }
 6402    // Value6 unsigned constant optional
 6403    if (ok) {
 6404        bool prs = lib_fast::GetPmapBit(pmap,6);
 6405        pmask_qSetBitVal(parent,Value6_Present_GetBit(parent),prs);
 6406    }
 6407    // Value7 unsigned constant optional
 6408    if (ok) {
 6409        bool prs = lib_fast::GetPmapBit(pmap,7);
 6410        pmask_qSetBitVal(parent,Value7_Present_GetBit(parent),prs);
 6411    }
 6412    // Value8 unsigned constant optional
 6413    if (ok) {
 6414        bool prs = lib_fast::GetPmapBit(pmap,8);
 6415        pmask_qSetBitVal(parent,Value8_Present_GetBit(parent),prs);
 6416    }
 6417    // Value9 unsigned constant optional
 6418    if (ok) {
 6419        bool prs = lib_fast::GetPmapBit(pmap,9);
 6420        pmask_qSetBitVal(parent,Value9_Present_GetBit(parent),prs);
 6421    }
 6422    // Value10 unsigned constant optional
 6423    if (ok) {
 6424        bool prs = lib_fast::GetPmapBit(pmap,10);
 6425        pmask_qSetBitVal(parent,Value10_Present_GetBit(parent),prs);
 6426    }
 6427    // Value11 unsigned constant optional
 6428    if (ok) {
 6429        bool prs = lib_fast::GetPmapBit(pmap,11);
 6430        pmask_qSetBitVal(parent,Value11_Present_GetBit(parent),prs);
 6431    }
 6432    // Value12 unsigned constant optional
 6433    if (ok) {
 6434        bool prs = lib_fast::GetPmapBit(pmap,12);
 6435        pmask_qSetBitVal(parent,Value12_Present_GetBit(parent),prs);
 6436    }
 6437    // Value13 unsigned constant optional
 6438    if (ok) {
 6439        bool prs = lib_fast::GetPmapBit(pmap,13);
 6440        pmask_qSetBitVal(parent,Value13_Present_GetBit(parent),prs);
 6441    }
 6442    // Value14 unsigned constant optional
 6443    if (ok) {
 6444        bool prs = lib_fast::GetPmapBit(pmap,14);
 6445        pmask_qSetBitVal(parent,Value14_Present_GetBit(parent),prs);
 6446    }
 6447    // Value15 unsigned constant optional
 6448    if (ok) {
 6449        bool prs = lib_fast::GetPmapBit(pmap,15);
 6450        pmask_qSetBitVal(parent,Value15_Present_GetBit(parent),prs);
 6451    }
 6452    // Value16 unsigned constant optional
 6453    if (ok) {
 6454        bool prs = lib_fast::GetPmapBit(pmap,16);
 6455        pmask_qSetBitVal(parent,Value16_Present_GetBit(parent),prs);
 6456    }
 6457    // Value17 unsigned constant optional
 6458    if (ok) {
 6459        bool prs = lib_fast::GetPmapBit(pmap,17);
 6460        pmask_qSetBitVal(parent,Value17_Present_GetBit(parent),prs);
 6461    }
 6462    // Value18 unsigned constant optional
 6463    if (ok) {
 6464        bool prs = lib_fast::GetPmapBit(pmap,18);
 6465        pmask_qSetBitVal(parent,Value18_Present_GetBit(parent),prs);
 6466    }
 6467    // Value19 unsigned constant optional
 6468    if (ok) {
 6469        bool prs = lib_fast::GetPmapBit(pmap,19);
 6470        pmask_qSetBitVal(parent,Value19_Present_GetBit(parent),prs);
 6471    }
 6472    // Value20 unsigned constant optional
 6473    if (ok) {
 6474        bool prs = lib_fast::GetPmapBit(pmap,20);
 6475        pmask_qSetBitVal(parent,Value20_Present_GetBit(parent),prs);
 6476    }
 6477    // Value21 unsigned constant optional
 6478    if (ok) {
 6479        bool prs = lib_fast::GetPmapBit(pmap,21);
 6480        pmask_qSetBitVal(parent,Value21_Present_GetBit(parent),prs);
 6481    }
 6482    // Value22 unsigned constant optional
 6483    if (ok) {
 6484        bool prs = lib_fast::GetPmapBit(pmap,22);
 6485        pmask_qSetBitVal(parent,Value22_Present_GetBit(parent),prs);
 6486    }
 6487    // Value23 unsigned constant optional
 6488    if (ok) {
 6489        bool prs = lib_fast::GetPmapBit(pmap,23);
 6490        pmask_qSetBitVal(parent,Value23_Present_GetBit(parent),prs);
 6491    }
 6492    // Value24 unsigned constant optional
 6493    if (ok) {
 6494        bool prs = lib_fast::GetPmapBit(pmap,24);
 6495        pmask_qSetBitVal(parent,Value24_Present_GetBit(parent),prs);
 6496    }
 6497    // Value25 unsigned constant optional
 6498    if (ok) {
 6499        bool prs = lib_fast::GetPmapBit(pmap,25);
 6500        pmask_qSetBitVal(parent,Value25_Present_GetBit(parent),prs);
 6501    }
 6502    // Value26 unsigned constant optional
 6503    if (ok) {
 6504        bool prs = lib_fast::GetPmapBit(pmap,26);
 6505        pmask_qSetBitVal(parent,Value26_Present_GetBit(parent),prs);
 6506    }
 6507    // Value27 unsigned constant optional
 6508    if (ok) {
 6509        bool prs = lib_fast::GetPmapBit(pmap,27);
 6510        pmask_qSetBitVal(parent,Value27_Present_GetBit(parent),prs);
 6511    }
 6512    // Value28 unsigned constant optional
 6513    if (ok) {
 6514        bool prs = lib_fast::GetPmapBit(pmap,28);
 6515        pmask_qSetBitVal(parent,Value28_Present_GetBit(parent),prs);
 6516    }
 6517    // Value29 unsigned constant optional
 6518    if (ok) {
 6519        bool prs = lib_fast::GetPmapBit(pmap,29);
 6520        pmask_qSetBitVal(parent,Value29_Present_GetBit(parent),prs);
 6521    }
 6522    // Value30 unsigned constant optional
 6523    if (ok) {
 6524        bool prs = lib_fast::GetPmapBit(pmap,30);
 6525        pmask_qSetBitVal(parent,Value30_Present_GetBit(parent),prs);
 6526    }
 6527    // Value31 unsigned constant optional
 6528    if (ok) {
 6529        bool prs = lib_fast::GetPmapBit(pmap,31);
 6530        pmask_qSetBitVal(parent,Value31_Present_GetBit(parent),prs);
 6531    }
 6532    // Value32 unsigned constant optional
 6533    if (ok) {
 6534        bool prs = lib_fast::GetPmapBit(pmap,32);
 6535        pmask_qSetBitVal(parent,Value32_Present_GetBit(parent),prs);
 6536    }
 6537    // Value33 unsigned constant optional
 6538    if (ok) {
 6539        bool prs = lib_fast::GetPmapBit(pmap,33);
 6540        pmask_qSetBitVal(parent,Value33_Present_GetBit(parent),prs);
 6541    }
 6542    // Value34 unsigned constant optional
 6543    if (ok) {
 6544        bool prs = lib_fast::GetPmapBit(pmap,34);
 6545        pmask_qSetBitVal(parent,Value34_Present_GetBit(parent),prs);
 6546    }
 6547    // Value35 unsigned constant optional
 6548    if (ok) {
 6549        bool prs = lib_fast::GetPmapBit(pmap,35);
 6550        pmask_qSetBitVal(parent,Value35_Present_GetBit(parent),prs);
 6551    }
 6552    // Value36 unsigned constant optional
 6553    if (ok) {
 6554        bool prs = lib_fast::GetPmapBit(pmap,36);
 6555        pmask_qSetBitVal(parent,Value36_Present_GetBit(parent),prs);
 6556    }
 6557    // Value37 unsigned constant optional
 6558    if (ok) {
 6559        bool prs = lib_fast::GetPmapBit(pmap,37);
 6560        pmask_qSetBitVal(parent,Value37_Present_GetBit(parent),prs);
 6561    }
 6562    // Value38 unsigned constant optional
 6563    if (ok) {
 6564        bool prs = lib_fast::GetPmapBit(pmap,38);
 6565        pmask_qSetBitVal(parent,Value38_Present_GetBit(parent),prs);
 6566    }
 6567    // Value39 unsigned constant optional
 6568    if (ok) {
 6569        bool prs = lib_fast::GetPmapBit(pmap,39);
 6570        pmask_qSetBitVal(parent,Value39_Present_GetBit(parent),prs);
 6571    }
 6572    // Value40 unsigned constant optional
 6573    if (ok) {
 6574        bool prs = lib_fast::GetPmapBit(pmap,40);
 6575        pmask_qSetBitVal(parent,Value40_Present_GetBit(parent),prs);
 6576    }
 6577    // Value41 unsigned constant optional
 6578    if (ok) {
 6579        bool prs = lib_fast::GetPmapBit(pmap,41);
 6580        pmask_qSetBitVal(parent,Value41_Present_GetBit(parent),prs);
 6581    }
 6582    // Value42 unsigned constant optional
 6583    if (ok) {
 6584        bool prs = lib_fast::GetPmapBit(pmap,42);
 6585        pmask_qSetBitVal(parent,Value42_Present_GetBit(parent),prs);
 6586    }
 6587    // Value43 unsigned constant optional
 6588    if (ok) {
 6589        bool prs = lib_fast::GetPmapBit(pmap,43);
 6590        pmask_qSetBitVal(parent,Value43_Present_GetBit(parent),prs);
 6591    }
 6592    // Value44 unsigned constant optional
 6593    if (ok) {
 6594        bool prs = lib_fast::GetPmapBit(pmap,44);
 6595        pmask_qSetBitVal(parent,Value44_Present_GetBit(parent),prs);
 6596    }
 6597    // Value45 unsigned constant optional
 6598    if (ok) {
 6599        bool prs = lib_fast::GetPmapBit(pmap,45);
 6600        pmask_qSetBitVal(parent,Value45_Present_GetBit(parent),prs);
 6601    }
 6602    // Value46 unsigned constant optional
 6603    if (ok) {
 6604        bool prs = lib_fast::GetPmapBit(pmap,46);
 6605        pmask_qSetBitVal(parent,Value46_Present_GetBit(parent),prs);
 6606    }
 6607    // Value47 unsigned constant optional
 6608    if (ok) {
 6609        bool prs = lib_fast::GetPmapBit(pmap,47);
 6610        pmask_qSetBitVal(parent,Value47_Present_GetBit(parent),prs);
 6611    }
 6612    // Value48 unsigned constant optional
 6613    if (ok) {
 6614        bool prs = lib_fast::GetPmapBit(pmap,48);
 6615        pmask_qSetBitVal(parent,Value48_Present_GetBit(parent),prs);
 6616    }
 6617    // Value49 unsigned constant optional
 6618    if (ok) {
 6619        bool prs = lib_fast::GetPmapBit(pmap,49);
 6620        pmask_qSetBitVal(parent,Value49_Present_GetBit(parent),prs);
 6621    }
 6622    // Value50 unsigned constant optional
 6623    if (ok) {
 6624        bool prs = lib_fast::GetPmapBit(pmap,50);
 6625        pmask_qSetBitVal(parent,Value50_Present_GetBit(parent),prs);
 6626    }
 6627    // Value51 unsigned constant optional
 6628    if (ok) {
 6629        bool prs = lib_fast::GetPmapBit(pmap,51);
 6630        pmask_qSetBitVal(parent,Value51_Present_GetBit(parent),prs);
 6631    }
 6632    // Value52 unsigned constant optional
 6633    if (ok) {
 6634        bool prs = lib_fast::GetPmapBit(pmap,52);
 6635        pmask_qSetBitVal(parent,Value52_Present_GetBit(parent),prs);
 6636    }
 6637    // Value53 unsigned constant optional
 6638    if (ok) {
 6639        bool prs = lib_fast::GetPmapBit(pmap,53);
 6640        pmask_qSetBitVal(parent,Value53_Present_GetBit(parent),prs);
 6641    }
 6642    // Value54 unsigned constant optional
 6643    if (ok) {
 6644        bool prs = lib_fast::GetPmapBit(pmap,54);
 6645        pmask_qSetBitVal(parent,Value54_Present_GetBit(parent),prs);
 6646    }
 6647    // Value55 unsigned constant optional
 6648    if (ok) {
 6649        bool prs = lib_fast::GetPmapBit(pmap,55);
 6650        pmask_qSetBitVal(parent,Value55_Present_GetBit(parent),prs);
 6651    }
 6652    // Value56 unsigned constant optional
 6653    if (ok) {
 6654        bool prs = lib_fast::GetPmapBit(pmap,56);
 6655        pmask_qSetBitVal(parent,Value56_Present_GetBit(parent),prs);
 6656    }
 6657    // Value57 unsigned constant optional
 6658    if (ok) {
 6659        bool prs = lib_fast::GetPmapBit(pmap,57);
 6660        pmask_qSetBitVal(parent,Value57_Present_GetBit(parent),prs);
 6661    }
 6662    // Value58 unsigned constant optional
 6663    if (ok) {
 6664        bool prs = lib_fast::GetPmapBit(pmap,58);
 6665        pmask_qSetBitVal(parent,Value58_Present_GetBit(parent),prs);
 6666    }
 6667    // Value59 unsigned constant optional
 6668    if (ok) {
 6669        bool prs = lib_fast::GetPmapBit(pmap,59);
 6670        pmask_qSetBitVal(parent,Value59_Present_GetBit(parent),prs);
 6671    }
 6672    // Value60 unsigned constant optional
 6673    if (ok) {
 6674        bool prs = lib_fast::GetPmapBit(pmap,60);
 6675        pmask_qSetBitVal(parent,Value60_Present_GetBit(parent),prs);
 6676    }
 6677    // Value61 unsigned constant optional
 6678    if (ok) {
 6679        bool prs = lib_fast::GetPmapBit(pmap,61);
 6680        pmask_qSetBitVal(parent,Value61_Present_GetBit(parent),prs);
 6681    }
 6682    // Value62 unsigned constant optional
 6683    if (ok) {
 6684        bool prs = lib_fast::GetPmapBit(pmap,62);
 6685        pmask_qSetBitVal(parent,Value62_Present_GetBit(parent),prs);
 6686    }
 6687    // Value63 unsigned constant optional
 6688    if (ok) {
 6689        bool prs = lib_fast::GetPmapBit(pmap,63);
 6690        pmask_qSetBitVal(parent,Value63_Present_GetBit(parent),prs);
 6691    }
 6692    (void)from;//only to avoid -Wunused-parameter
 6693    (void)state;//only to avoid -Wunused-parameter
 6694    return ok;
 6695}
 6696
 6697// --- fasttest.MsgPmap..FixEncode
 6698void fasttest::MsgPmap_FixEncode(cstring& buf, fasttest::MsgPmap& parent, char soh) {
 6699    if (Value1_PresentQ(parent)) {
 6700        buf << "1=" << Value1_Get(parent) << soh;
 6701    }
 6702    if (Value2_PresentQ(parent)) {
 6703        buf << "2=" << Value2_Get(parent) << soh;
 6704    }
 6705    if (Value3_PresentQ(parent)) {
 6706        buf << "3=" << Value3_Get(parent) << soh;
 6707    }
 6708    if (Value4_PresentQ(parent)) {
 6709        buf << "4=" << Value4_Get(parent) << soh;
 6710    }
 6711    if (Value5_PresentQ(parent)) {
 6712        buf << "5=" << Value5_Get(parent) << soh;
 6713    }
 6714    if (Value6_PresentQ(parent)) {
 6715        buf << "6=" << Value6_Get(parent) << soh;
 6716    }
 6717    if (Value7_PresentQ(parent)) {
 6718        buf << "7=" << Value7_Get(parent) << soh;
 6719    }
 6720    if (Value8_PresentQ(parent)) {
 6721        buf << "8=" << Value8_Get(parent) << soh;
 6722    }
 6723    if (Value9_PresentQ(parent)) {
 6724        buf << "9=" << Value9_Get(parent) << soh;
 6725    }
 6726    if (Value10_PresentQ(parent)) {
 6727        buf << "10=" << Value10_Get(parent) << soh;
 6728    }
 6729    if (Value11_PresentQ(parent)) {
 6730        buf << "11=" << Value11_Get(parent) << soh;
 6731    }
 6732    if (Value12_PresentQ(parent)) {
 6733        buf << "12=" << Value12_Get(parent) << soh;
 6734    }
 6735    if (Value13_PresentQ(parent)) {
 6736        buf << "13=" << Value13_Get(parent) << soh;
 6737    }
 6738    if (Value14_PresentQ(parent)) {
 6739        buf << "14=" << Value14_Get(parent) << soh;
 6740    }
 6741    if (Value15_PresentQ(parent)) {
 6742        buf << "15=" << Value15_Get(parent) << soh;
 6743    }
 6744    if (Value16_PresentQ(parent)) {
 6745        buf << "16=" << Value16_Get(parent) << soh;
 6746    }
 6747    if (Value17_PresentQ(parent)) {
 6748        buf << "17=" << Value17_Get(parent) << soh;
 6749    }
 6750    if (Value18_PresentQ(parent)) {
 6751        buf << "18=" << Value18_Get(parent) << soh;
 6752    }
 6753    if (Value19_PresentQ(parent)) {
 6754        buf << "19=" << Value19_Get(parent) << soh;
 6755    }
 6756    if (Value20_PresentQ(parent)) {
 6757        buf << "20=" << Value20_Get(parent) << soh;
 6758    }
 6759    if (Value21_PresentQ(parent)) {
 6760        buf << "21=" << Value21_Get(parent) << soh;
 6761    }
 6762    if (Value22_PresentQ(parent)) {
 6763        buf << "22=" << Value22_Get(parent) << soh;
 6764    }
 6765    if (Value23_PresentQ(parent)) {
 6766        buf << "23=" << Value23_Get(parent) << soh;
 6767    }
 6768    if (Value24_PresentQ(parent)) {
 6769        buf << "24=" << Value24_Get(parent) << soh;
 6770    }
 6771    if (Value25_PresentQ(parent)) {
 6772        buf << "25=" << Value25_Get(parent) << soh;
 6773    }
 6774    if (Value26_PresentQ(parent)) {
 6775        buf << "26=" << Value26_Get(parent) << soh;
 6776    }
 6777    if (Value27_PresentQ(parent)) {
 6778        buf << "27=" << Value27_Get(parent) << soh;
 6779    }
 6780    if (Value28_PresentQ(parent)) {
 6781        buf << "28=" << Value28_Get(parent) << soh;
 6782    }
 6783    if (Value29_PresentQ(parent)) {
 6784        buf << "29=" << Value29_Get(parent) << soh;
 6785    }
 6786    if (Value30_PresentQ(parent)) {
 6787        buf << "30=" << Value30_Get(parent) << soh;
 6788    }
 6789    if (Value31_PresentQ(parent)) {
 6790        buf << "31=" << Value31_Get(parent) << soh;
 6791    }
 6792    if (Value32_PresentQ(parent)) {
 6793        buf << "32=" << Value32_Get(parent) << soh;
 6794    }
 6795    if (Value33_PresentQ(parent)) {
 6796        buf << "33=" << Value33_Get(parent) << soh;
 6797    }
 6798    if (Value34_PresentQ(parent)) {
 6799        buf << "34=" << Value34_Get(parent) << soh;
 6800    }
 6801    if (Value35_PresentQ(parent)) {
 6802        buf << "35=" << Value35_Get(parent) << soh;
 6803    }
 6804    if (Value36_PresentQ(parent)) {
 6805        buf << "36=" << Value36_Get(parent) << soh;
 6806    }
 6807    if (Value37_PresentQ(parent)) {
 6808        buf << "37=" << Value37_Get(parent) << soh;
 6809    }
 6810    if (Value38_PresentQ(parent)) {
 6811        buf << "38=" << Value38_Get(parent) << soh;
 6812    }
 6813    if (Value39_PresentQ(parent)) {
 6814        buf << "39=" << Value39_Get(parent) << soh;
 6815    }
 6816    if (Value40_PresentQ(parent)) {
 6817        buf << "40=" << Value40_Get(parent) << soh;
 6818    }
 6819    if (Value41_PresentQ(parent)) {
 6820        buf << "41=" << Value41_Get(parent) << soh;
 6821    }
 6822    if (Value42_PresentQ(parent)) {
 6823        buf << "42=" << Value42_Get(parent) << soh;
 6824    }
 6825    if (Value43_PresentQ(parent)) {
 6826        buf << "43=" << Value43_Get(parent) << soh;
 6827    }
 6828    if (Value44_PresentQ(parent)) {
 6829        buf << "44=" << Value44_Get(parent) << soh;
 6830    }
 6831    if (Value45_PresentQ(parent)) {
 6832        buf << "45=" << Value45_Get(parent) << soh;
 6833    }
 6834    if (Value46_PresentQ(parent)) {
 6835        buf << "46=" << Value46_Get(parent) << soh;
 6836    }
 6837    if (Value47_PresentQ(parent)) {
 6838        buf << "47=" << Value47_Get(parent) << soh;
 6839    }
 6840    if (Value48_PresentQ(parent)) {
 6841        buf << "48=" << Value48_Get(parent) << soh;
 6842    }
 6843    if (Value49_PresentQ(parent)) {
 6844        buf << "49=" << Value49_Get(parent) << soh;
 6845    }
 6846    if (Value50_PresentQ(parent)) {
 6847        buf << "50=" << Value50_Get(parent) << soh;
 6848    }
 6849    if (Value51_PresentQ(parent)) {
 6850        buf << "51=" << Value51_Get(parent) << soh;
 6851    }
 6852    if (Value52_PresentQ(parent)) {
 6853        buf << "52=" << Value52_Get(parent) << soh;
 6854    }
 6855    if (Value53_PresentQ(parent)) {
 6856        buf << "53=" << Value53_Get(parent) << soh;
 6857    }
 6858    if (Value54_PresentQ(parent)) {
 6859        buf << "54=" << Value54_Get(parent) << soh;
 6860    }
 6861    if (Value55_PresentQ(parent)) {
 6862        buf << "55=" << Value55_Get(parent) << soh;
 6863    }
 6864    if (Value56_PresentQ(parent)) {
 6865        buf << "56=" << Value56_Get(parent) << soh;
 6866    }
 6867    if (Value57_PresentQ(parent)) {
 6868        buf << "57=" << Value57_Get(parent) << soh;
 6869    }
 6870    if (Value58_PresentQ(parent)) {
 6871        buf << "58=" << Value58_Get(parent) << soh;
 6872    }
 6873    if (Value59_PresentQ(parent)) {
 6874        buf << "59=" << Value59_Get(parent) << soh;
 6875    }
 6876    if (Value60_PresentQ(parent)) {
 6877        buf << "60=" << Value60_Get(parent) << soh;
 6878    }
 6879    if (Value61_PresentQ(parent)) {
 6880        buf << "61=" << Value61_Get(parent) << soh;
 6881    }
 6882    if (Value62_PresentQ(parent)) {
 6883        buf << "62=" << Value62_Get(parent) << soh;
 6884    }
 6885    if (Value63_PresentQ(parent)) {
 6886        buf << "63=" << Value63_Get(parent) << soh;
 6887    }
 6888}
 6889
 6890// --- fasttest.OptSgmSeq..ReadFieldMaybe
 6891bool fasttest::OptSgmSeq_ReadFieldMaybe(fasttest::OptSgmSeq& parent, algo::strptr field, algo::strptr strval) {
 6892    bool retval = true;
 6893    fasttest::FieldId field_id;
 6894    (void)value_SetStrptrMaybe(field_id,field);
 6895    switch(field_id) {
 6896        case fasttest_FieldId_Value: {
 6897            retval = u32_ReadStrptrMaybe(parent.Value, strval);
 6898            break;
 6899        }
 6900        default: break;
 6901    }
 6902    if (!retval) {
 6903        algo_lib::AppendErrtext("attr",field);
 6904    }
 6905    return retval;
 6906}
 6907
 6908// --- fasttest.OptSgmSeq..ReadStrptrMaybe
 6909// Read fields of fasttest::OptSgmSeq from an ascii string.
 6910// The format of the string is an ssim Tuple
 6911bool fasttest::OptSgmSeq_ReadStrptrMaybe(fasttest::OptSgmSeq &parent, algo::strptr in_str) {
 6912    bool retval = true;
 6913    retval = algo::StripTypeTag(in_str, "fasttest.OptSgmSeq");
 6914    ind_beg(algo::Attr_curs, attr, in_str) {
 6915        retval = retval && OptSgmSeq_ReadFieldMaybe(parent, attr.name, attr.value);
 6916    }ind_end;
 6917    return retval;
 6918}
 6919
 6920// --- fasttest.OptSgmSeq..Print
 6921// print string representation of ROW to string STR
 6922// cfmt:fasttest.OptSgmSeq.String  printfmt:Tuple
 6923void fasttest::OptSgmSeq_Print(fasttest::OptSgmSeq& row, algo::cstring& str) {
 6924    algo::tempstr temp;
 6925    str << "fasttest.OptSgmSeq";
 6926
 6927    u32_Print(row.Value, temp);
 6928    PrintAttrSpaceReset(str,"Value", temp);
 6929}
 6930
 6931// --- fasttest.OptSgmSeq..FastEncode
 6932void fasttest::OptSgmSeq_FastEncode(algo::ByteAry& buf, FastState& state, fasttest::OptSgmSeq& parent) {
 6933    int index = ary_N(buf);
 6934    u64 pmap(0);
 6935    // Value unsigned default mandatory
 6936    if (parent.Value != 1) {
 6937        lib_fast::EncodeUnsigned(buf,parent.Value,false);
 6938        lib_fast::SetPmapBit(pmap,0);
 6939    }
 6940    lib_fast::InsertPmap(buf,index,pmap);
 6941    (void)state;//only to avoid -Wunused-parameter
 6942}
 6943
 6944// --- fasttest.OptSgmSeq..FastDecode
 6945bool fasttest::OptSgmSeq_FastDecode(algo::memptr& from, FastState& state, fasttest::OptSgmSeq& parent) {
 6946    bool ok = true;
 6947    u64 pmap;
 6948    ok = lib_fast::DecodePmap(from,pmap);
 6949    if (!ok) {
 6950        state.error << "fasttest.OptSgmSeq: bad pmap" << eol;
 6951    }
 6952    // Value unsigned default mandatory
 6953    if (ok) {
 6954        bool prs = lib_fast::GetPmapBit(pmap,0);
 6955        if (prs) {
 6956            ok = lib_fast::DecodeUnsigned(from,parent.Value,false);
 6957            if (!ok) {
 6958                state.error << "fasttest.OptSgmSeq.Value: bad Unsigned" << eol;
 6959            }
 6960        } else {
 6961            parent.Value = 1;
 6962        }
 6963    }
 6964    return ok;
 6965}
 6966
 6967// --- fasttest.OptSgmSeq..FixEncode
 6968void fasttest::OptSgmSeq_FixEncode(cstring& buf, fasttest::OptSgmSeq& parent, char soh) {
 6969    buf << "2=" << parent.Value << soh;
 6970}
 6971
 6972// --- fasttest.OptTrvSeq..ReadFieldMaybe
 6973bool fasttest::OptTrvSeq_ReadFieldMaybe(fasttest::OptTrvSeq& parent, algo::strptr field, algo::strptr strval) {
 6974    bool retval = true;
 6975    fasttest::FieldId field_id;
 6976    (void)value_SetStrptrMaybe(field_id,field);
 6977    switch(field_id) {
 6978        case fasttest_FieldId_Value: {
 6979            retval = u32_ReadStrptrMaybe(parent.Value, strval);
 6980            break;
 6981        }
 6982        default: break;
 6983    }
 6984    if (!retval) {
 6985        algo_lib::AppendErrtext("attr",field);
 6986    }
 6987    return retval;
 6988}
 6989
 6990// --- fasttest.OptTrvSeq..ReadStrptrMaybe
 6991// Read fields of fasttest::OptTrvSeq from an ascii string.
 6992// The format of the string is an ssim Tuple
 6993bool fasttest::OptTrvSeq_ReadStrptrMaybe(fasttest::OptTrvSeq &parent, algo::strptr in_str) {
 6994    bool retval = true;
 6995    retval = algo::StripTypeTag(in_str, "fasttest.OptTrvSeq");
 6996    ind_beg(algo::Attr_curs, attr, in_str) {
 6997        retval = retval && OptTrvSeq_ReadFieldMaybe(parent, attr.name, attr.value);
 6998    }ind_end;
 6999    return retval;
 7000}
 7001
 7002// --- fasttest.OptTrvSeq..Print
 7003// print string representation of ROW to string STR
 7004// cfmt:fasttest.OptTrvSeq.String  printfmt:Tuple
 7005void fasttest::OptTrvSeq_Print(fasttest::OptTrvSeq& row, algo::cstring& str) {
 7006    algo::tempstr temp;
 7007    str << "fasttest.OptTrvSeq";
 7008
 7009    u32_Print(row.Value, temp);
 7010    PrintAttrSpaceReset(str,"Value", temp);
 7011}
 7012
 7013// --- fasttest.OptTrvSeq..FastEncode
 7014void fasttest::OptTrvSeq_FastEncode(algo::ByteAry& buf, FastState& state, fasttest::OptTrvSeq& parent) {
 7015    // Value unsigned none mandatory
 7016    lib_fast::EncodeUnsigned(buf,parent.Value,false);
 7017    (void)state;//only to avoid -Wunused-parameter
 7018}
 7019
 7020// --- fasttest.OptTrvSeq..FastDecode
 7021bool fasttest::OptTrvSeq_FastDecode(algo::memptr& from, FastState& state, fasttest::OptTrvSeq& parent) {
 7022    bool ok = true;
 7023    // Value unsigned none mandatory
 7024    if (ok) {
 7025        ok = lib_fast::DecodeUnsigned(from,parent.Value,false);
 7026        if (!ok) {
 7027            state.error << "fasttest.OptTrvSeq.Value: bad Unsigned" << eol;
 7028        }
 7029    }
 7030    return ok;
 7031}
 7032
 7033// --- fasttest.OptTrvSeq..FixEncode
 7034void fasttest::OptTrvSeq_FixEncode(cstring& buf, fasttest::OptTrvSeq& parent, char soh) {
 7035    buf << "2=" << parent.Value << soh;
 7036}
 7037
 7038// --- fasttest.Reset.base.CopyOut
 7039// Copy fields out of row
 7040void fasttest::parent_CopyOut(fasttest::Reset &row, fasttest::TemplateHeader &out) {
 7041    // length: field value is computed
 7042    // id: field value is computed
 7043    (void)row;//only to avoid -Wunused-parameter
 7044    (void)out;//only to avoid -Wunused-parameter
 7045}
 7046
 7047// --- fasttest.Reset..ReadFieldMaybe
 7048bool fasttest::Reset_ReadFieldMaybe(fasttest::Reset& parent, algo::strptr field, algo::strptr strval) {
 7049    bool retval = true;
 7050    fasttest::FieldId field_id;
 7051    (void)value_SetStrptrMaybe(field_id,field);
 7052    switch(field_id) {
 7053        case fasttest_FieldId_base: {
 7054            retval = false;
 7055            break;
 7056        }
 7057        case fasttest_FieldId_length: {
 7058            retval = false;
 7059            break;
 7060        }
 7061        case fasttest_FieldId_id: {
 7062            retval = false;
 7063            break;
 7064        }
 7065        default: break;
 7066    }
 7067    if (!retval) {
 7068        algo_lib::AppendErrtext("attr",field);
 7069    }
 7070    (void)parent;//only to avoid -Wunused-parameter
 7071    (void)strval;//only to avoid -Wunused-parameter
 7072    return retval;
 7073}
 7074
 7075// --- fasttest.Reset..ReadStrptrMaybe
 7076// Read fields of fasttest::Reset from an ascii string.
 7077// The format of the string is an ssim Tuple
 7078bool fasttest::Reset_ReadStrptrMaybe(fasttest::Reset &parent, algo::strptr in_str) {
 7079    bool retval = true;
 7080    retval = algo::StripTypeTag(in_str, "fasttest.Reset");
 7081    ind_beg(algo::Attr_curs, attr, in_str) {
 7082        retval = retval && Reset_ReadFieldMaybe(parent, attr.name, attr.value);
 7083    }ind_end;
 7084    return retval;
 7085}
 7086
 7087// --- fasttest.Reset..Print
 7088// print string representation of ROW to string STR
 7089// cfmt:fasttest.Reset.String  printfmt:Tuple
 7090void fasttest::Reset_Print(fasttest::Reset& row, algo::cstring& str) {
 7091    algo::tempstr temp;
 7092    str << "fasttest.Reset";
 7093    (void)row;//only to avoid -Wunused-parameter
 7094}
 7095
 7096// --- fasttest.Reset..FastEncode
 7097void fasttest::Reset_FastEncode(algo::ByteAry& buf, FastState& state, fasttest::Reset& parent) {
 7098    int index = ary_N(buf);
 7099    u64 pmap(0);
 7100    if (!tid_AssignedQ(state) || parent.id != state.tid) {
 7101        lib_fast::EncodeUnsigned(buf,parent.id,false);
 7102        lib_fast::SetPmapBit(pmap,0);
 7103    }
 7104    tid_SetAssigned(state);
 7105    state.tid = parent.id;
 7106    lib_fast::InsertPmap(buf,index,pmap);
 7107}
 7108
 7109// --- fasttest.Reset..FastDecode
 7110bool fasttest::Reset_FastDecode(algo::memptr& from, u64 pmap, FastState& state, fasttest::Reset& parent) {
 7111    bool ok = true;
 7112    (void)from;//only to avoid -Wunused-parameter
 7113    (void)pmap;//only to avoid -Wunused-parameter
 7114    (void)state;//only to avoid -Wunused-parameter
 7115    (void)parent;//only to avoid -Wunused-parameter
 7116    return ok;
 7117}
 7118
 7119// --- fasttest.Reset..FixEncode
 7120void fasttest::Reset_FixEncode(cstring& buf, fasttest::Reset& parent, char soh) {
 7121    (void)buf;//only to avoid -Wunused-parameter
 7122    (void)parent;//only to avoid -Wunused-parameter
 7123    (void)soh;//only to avoid -Wunused-parameter
 7124}
 7125
 7126// --- fasttest.SampleEnumConst.base.CopyOut
 7127// Copy fields out of row
 7128void fasttest::parent_CopyOut(fasttest::SampleEnumConst &row, fasttest::TemplateHeader &out) {
 7129    // length: field value is computed
 7130    // id: field value is computed
 7131    (void)row;//only to avoid -Wunused-parameter
 7132    (void)out;//only to avoid -Wunused-parameter
 7133}
 7134
 7135// --- fasttest.SampleEnumConst..ReadFieldMaybe
 7136bool fasttest::SampleEnumConst_ReadFieldMaybe(fasttest::SampleEnumConst& parent, algo::strptr field, algo::strptr strval) {
 7137    bool retval = true;
 7138    fasttest::FieldId field_id;
 7139    (void)value_SetStrptrMaybe(field_id,field);
 7140    switch(field_id) {
 7141        case fasttest_FieldId_base: {
 7142            retval = false;
 7143            break;
 7144        }
 7145        case fasttest_FieldId_length: {
 7146            retval = false;
 7147            break;
 7148        }
 7149        case fasttest_FieldId_id: {
 7150            retval = false;
 7151            break;
 7152        }
 7153        case fasttest_FieldId_Value: {
 7154            retval = true;
 7155            break;
 7156        }
 7157        default: break;
 7158    }
 7159    if (!retval) {
 7160        algo_lib::AppendErrtext("attr",field);
 7161    }
 7162    (void)parent;//only to avoid -Wunused-parameter
 7163    (void)strval;//only to avoid -Wunused-parameter
 7164    return retval;
 7165}
 7166
 7167// --- fasttest.SampleEnumConst..ReadStrptrMaybe
 7168// Read fields of fasttest::SampleEnumConst from an ascii string.
 7169// The format of the string is an ssim Tuple
 7170bool fasttest::SampleEnumConst_ReadStrptrMaybe(fasttest::SampleEnumConst &parent, algo::strptr in_str) {
 7171    bool retval = true;
 7172    retval = algo::StripTypeTag(in_str, "fasttest.SampleEnumConst");
 7173    ind_beg(algo::Attr_curs, attr, in_str) {
 7174        retval = retval && SampleEnumConst_ReadFieldMaybe(parent, attr.name, attr.value);
 7175    }ind_end;
 7176    return retval;
 7177}
 7178
 7179// --- fasttest.SampleEnumConst..Print
 7180// print string representation of ROW to string STR
 7181// cfmt:fasttest.SampleEnumConst.String  printfmt:Tuple
 7182void fasttest::SampleEnumConst_Print(fasttest::SampleEnumConst& row, algo::cstring& str) {
 7183    algo::tempstr temp;
 7184    str << "fasttest.SampleEnumConst";
 7185
 7186    fasttest::SampleEnum_Print(Value_Get(row), temp);
 7187    PrintAttrSpaceReset(str,"Value", temp);
 7188}
 7189
 7190// --- fasttest.SampleEnumConst..FastEncode
 7191void fasttest::SampleEnumConst_FastEncode(algo::ByteAry& buf, FastState& state, fasttest::SampleEnumConst& parent) {
 7192    int index = ary_N(buf);
 7193    u64 pmap(0);
 7194    if (!tid_AssignedQ(state) || parent.id != state.tid) {
 7195        lib_fast::EncodeUnsigned(buf,parent.id,false);
 7196        lib_fast::SetPmapBit(pmap,0);
 7197    }
 7198    tid_SetAssigned(state);
 7199    state.tid = parent.id;
 7200    // Value type constant mandatory
 7201    lib_fast::InsertPmap(buf,index,pmap);
 7202}
 7203
 7204// --- fasttest.SampleEnumConst..FastDecode
 7205bool fasttest::SampleEnumConst_FastDecode(algo::memptr& from, u64 pmap, FastState& state, fasttest::SampleEnumConst& parent) {
 7206    bool ok = true;
 7207    // Value type constant mandatory
 7208    if (ok) {
 7209    }
 7210    (void)from;//only to avoid -Wunused-parameter
 7211    (void)pmap;//only to avoid -Wunused-parameter
 7212    (void)state;//only to avoid -Wunused-parameter
 7213    (void)parent;//only to avoid -Wunused-parameter
 7214    return ok;
 7215}
 7216
 7217// --- fasttest.SampleEnumConst..FixEncode
 7218void fasttest::SampleEnumConst_FixEncode(cstring& buf, fasttest::SampleEnumConst& parent, char soh) {
 7219    buf << "1=" << Value_Get(parent) << soh;
 7220}
 7221
 7222// --- fasttest.SampleEnumCopy.base.CopyOut
 7223// Copy fields out of row
 7224void fasttest::parent_CopyOut(fasttest::SampleEnumCopy &row, fasttest::TemplateHeader &out) {
 7225    // length: field value is computed
 7226    // id: field value is computed
 7227    (void)row;//only to avoid -Wunused-parameter
 7228    (void)out;//only to avoid -Wunused-parameter
 7229}
 7230
 7231// --- fasttest.SampleEnumCopy..ReadFieldMaybe
 7232bool fasttest::SampleEnumCopy_ReadFieldMaybe(fasttest::SampleEnumCopy& parent, algo::strptr field, algo::strptr strval) {
 7233    bool retval = true;
 7234    fasttest::FieldId field_id;
 7235    (void)value_SetStrptrMaybe(field_id,field);
 7236    switch(field_id) {
 7237        case fasttest_FieldId_base: {
 7238            retval = false;
 7239            break;
 7240        }
 7241        case fasttest_FieldId_length: {
 7242            retval = false;
 7243            break;
 7244        }
 7245        case fasttest_FieldId_id: {
 7246            retval = false;
 7247            break;
 7248        }
 7249        case fasttest_FieldId_Value147: {
 7250            retval = fasttest::SampleEnum_ReadStrptrMaybe(parent.Value147, strval);
 7251            break;
 7252        }
 7253        default: break;
 7254    }
 7255    if (!retval) {
 7256        algo_lib::AppendErrtext("attr",field);
 7257    }
 7258    return retval;
 7259}
 7260
 7261// --- fasttest.SampleEnumCopy..ReadStrptrMaybe
 7262// Read fields of fasttest::SampleEnumCopy from an ascii string.
 7263// The format of the string is an ssim Tuple
 7264bool fasttest::SampleEnumCopy_ReadStrptrMaybe(fasttest::SampleEnumCopy &parent, algo::strptr in_str) {
 7265    bool retval = true;
 7266    retval = algo::StripTypeTag(in_str, "fasttest.SampleEnumCopy");
 7267    ind_beg(algo::Attr_curs, attr, in_str) {
 7268        retval = retval && SampleEnumCopy_ReadFieldMaybe(parent, attr.name, attr.value);
 7269    }ind_end;
 7270    return retval;
 7271}
 7272
 7273// --- fasttest.SampleEnumCopy..Print
 7274// print string representation of ROW to string STR
 7275// cfmt:fasttest.SampleEnumCopy.String  printfmt:Tuple
 7276void fasttest::SampleEnumCopy_Print(fasttest::SampleEnumCopy& row, algo::cstring& str) {
 7277    algo::tempstr temp;
 7278    str << "fasttest.SampleEnumCopy";
 7279
 7280    fasttest::SampleEnum_Print(row.Value147, temp);
 7281    PrintAttrSpaceReset(str,"Value147", temp);
 7282}
 7283
 7284// --- fasttest.SampleEnumCopy..FastEncode
 7285void fasttest::SampleEnumCopy_FastEncode(algo::ByteAry& buf, FastState& state, fasttest::SampleEnumCopy& parent) {
 7286    int index = ary_N(buf);
 7287    u64 pmap(0);
 7288    if (!tid_AssignedQ(state) || parent.id != state.tid) {
 7289        lib_fast::EncodeUnsigned(buf,parent.id,false);
 7290        lib_fast::SetPmapBit(pmap,0);
 7291    }
 7292    tid_SetAssigned(state);
 7293    state.tid = parent.id;
 7294    // Value147 type copy mandatory
 7295    if (Value147_AssignedQ(state) ? parent.Value147.value != state.Value147.value : parent.Value147.value != 0) {
 7296        lib_fast::EncodeUnsigned(buf,parent.Value147.value,false);
 7297        lib_fast::SetPmapBit(pmap,1);
 7298    }
 7299    state.Value147.value = parent.Value147.value;
 7300    Value147_SetAssigned(state);
 7301    lib_fast::InsertPmap(buf,index,pmap);
 7302}
 7303
 7304// --- fasttest.SampleEnumCopy..FastDecode
 7305bool fasttest::SampleEnumCopy_FastDecode(algo::memptr& from, u64 pmap, FastState& state, fasttest::SampleEnumCopy& parent) {
 7306    bool ok = true;
 7307    // Value147 type copy mandatory
 7308    if (ok) {
 7309        bool prs = lib_fast::GetPmapBit(pmap,1);
 7310        if (prs) {
 7311            ok = lib_fast::DecodeUnsigned(from,parent.Value147.value,false);
 7312            if (!ok) {
 7313                state.error << "fasttest.SampleEnumCopy.Value147: bad Unsigned" << eol;
 7314            }
 7315        } else if (Value147_AssignedQ(state)) {
 7316            parent.Value147.value = state.Value147.value;
 7317        } else {
 7318            parent.Value147.value = 0;
 7319        }
 7320        Value147_SetAssigned(state);
 7321        state.Value147.value = parent.Value147.value;
 7322    }
 7323    return ok;
 7324}
 7325
 7326// --- fasttest.SampleEnumCopy..FixEncode
 7327void fasttest::SampleEnumCopy_FixEncode(cstring& buf, fasttest::SampleEnumCopy& parent, char soh) {
 7328    buf << "1=" << parent.Value147 << soh;
 7329}
 7330
 7331// --- fasttest.SampleEnumDefault.base.CopyOut
 7332// Copy fields out of row
 7333void fasttest::parent_CopyOut(fasttest::SampleEnumDefault &row, fasttest::TemplateHeader &out) {
 7334    // length: field value is computed
 7335    // id: field value is computed
 7336    (void)row;//only to avoid -Wunused-parameter
 7337    (void)out;//only to avoid -Wunused-parameter
 7338}
 7339
 7340// --- fasttest.SampleEnumDefault..ReadFieldMaybe
 7341bool fasttest::SampleEnumDefault_ReadFieldMaybe(fasttest::SampleEnumDefault& parent, algo::strptr field, algo::strptr strval) {
 7342    bool retval = true;
 7343    fasttest::FieldId field_id;
 7344    (void)value_SetStrptrMaybe(field_id,field);
 7345    switch(field_id) {
 7346        case fasttest_FieldId_base: {
 7347            retval = false;
 7348            break;
 7349        }
 7350        case fasttest_FieldId_length: {
 7351            retval = false;
 7352            break;
 7353        }
 7354        case fasttest_FieldId_id: {
 7355            retval = false;
 7356            break;
 7357        }
 7358        case fasttest_FieldId_Value: {
 7359            retval = fasttest::SampleEnum_ReadStrptrMaybe(parent.Value, strval);
 7360            break;
 7361        }
 7362        default: break;
 7363    }
 7364    if (!retval) {
 7365        algo_lib::AppendErrtext("attr",field);
 7366    }
 7367    return retval;
 7368}
 7369
 7370// --- fasttest.SampleEnumDefault..ReadStrptrMaybe
 7371// Read fields of fasttest::SampleEnumDefault from an ascii string.
 7372// The format of the string is an ssim Tuple
 7373bool fasttest::SampleEnumDefault_ReadStrptrMaybe(fasttest::SampleEnumDefault &parent, algo::strptr in_str) {
 7374    bool retval = true;
 7375    retval = algo::StripTypeTag(in_str, "fasttest.SampleEnumDefault");
 7376    ind_beg(algo::Attr_curs, attr, in_str) {
 7377        retval = retval && SampleEnumDefault_ReadFieldMaybe(parent, attr.name, attr.value);
 7378    }ind_end;
 7379    return retval;
 7380}
 7381
 7382// --- fasttest.SampleEnumDefault..Print
 7383// print string representation of ROW to string STR
 7384// cfmt:fasttest.SampleEnumDefault.String  printfmt:Tuple
 7385void fasttest::SampleEnumDefault_Print(fasttest::SampleEnumDefault& row, algo::cstring& str) {
 7386    algo::tempstr temp;
 7387    str << "fasttest.SampleEnumDefault";
 7388
 7389    fasttest::SampleEnum_Print(row.Value, temp);
 7390    PrintAttrSpaceReset(str,"Value", temp);
 7391}
 7392
 7393// --- fasttest.SampleEnumDefault..FastEncode
 7394void fasttest::SampleEnumDefault_FastEncode(algo::ByteAry& buf, FastState& state, fasttest::SampleEnumDefault& parent) {
 7395    int index = ary_N(buf);
 7396    u64 pmap(0);
 7397    if (!tid_AssignedQ(state) || parent.id != state.tid) {
 7398        lib_fast::EncodeUnsigned(buf,parent.id,false);
 7399        lib_fast::SetPmapBit(pmap,0);
 7400    }
 7401    tid_SetAssigned(state);
 7402    state.tid = parent.id;
 7403    // Value type default mandatory
 7404    if (parent.Value.value != 2) {
 7405        lib_fast::EncodeUnsigned(buf,parent.Value.value,false);
 7406        lib_fast::SetPmapBit(pmap,1);
 7407    }
 7408    lib_fast::InsertPmap(buf,index,pmap);
 7409}
 7410
 7411// --- fasttest.SampleEnumDefault..FastDecode
 7412bool fasttest::SampleEnumDefault_FastDecode(algo::memptr& from, u64 pmap, FastState& state, fasttest::SampleEnumDefault& parent) {
 7413    bool ok = true;
 7414    // Value type default mandatory
 7415    if (ok) {
 7416        bool prs = lib_fast::GetPmapBit(pmap,1);
 7417        if (prs) {
 7418            ok = lib_fast::DecodeUnsigned(from,parent.Value.value,false);
 7419            if (!ok) {
 7420                state.error << "fasttest.SampleEnumDefault.Value: bad Unsigned" << eol;
 7421            }
 7422        } else {
 7423            parent.Value.value = 2;
 7424        }
 7425    }
 7426    return ok;
 7427}
 7428
 7429// --- fasttest.SampleEnumDefault..FixEncode
 7430void fasttest::SampleEnumDefault_FixEncode(cstring& buf, fasttest::SampleEnumDefault& parent, char soh) {
 7431    buf << "1=" << parent.Value << soh;
 7432}
 7433
 7434// --- fasttest.SampleSetConst.base.CopyOut
 7435// Copy fields out of row
 7436void fasttest::parent_CopyOut(fasttest::SampleSetConst &row, fasttest::TemplateHeader &out) {
 7437    // length: field value is computed
 7438    // id: field value is computed
 7439    (void)row;//only to avoid -Wunused-parameter
 7440    (void)out;//only to avoid -Wunused-parameter
 7441}
 7442
 7443// --- fasttest.SampleSetConst..ReadFieldMaybe
 7444bool fasttest::SampleSetConst_ReadFieldMaybe(fasttest::SampleSetConst& parent, algo::strptr field, algo::strptr strval) {
 7445    bool retval = true;
 7446    fasttest::FieldId field_id;
 7447    (void)value_SetStrptrMaybe(field_id,field);
 7448    switch(field_id) {
 7449        case fasttest_FieldId_base: {
 7450            retval = false;
 7451            break;
 7452        }
 7453        case fasttest_FieldId_length: {
 7454            retval = false;
 7455            break;
 7456        }
 7457        case fasttest_FieldId_id: {
 7458            retval = false;
 7459            break;
 7460        }
 7461        case fasttest_FieldId_Value: {
 7462            retval = true;
 7463            break;
 7464        }
 7465        default: break;
 7466    }
 7467    if (!retval) {
 7468        algo_lib::AppendErrtext("attr",field);
 7469    }
 7470    (void)parent;//only to avoid -Wunused-parameter
 7471    (void)strval;//only to avoid -Wunused-parameter
 7472    return retval;
 7473}
 7474
 7475// --- fasttest.SampleSetConst..ReadStrptrMaybe
 7476// Read fields of fasttest::SampleSetConst from an ascii string.
 7477// The format of the string is an ssim Tuple
 7478bool fasttest::SampleSetConst_ReadStrptrMaybe(fasttest::SampleSetConst &parent, algo::strptr in_str) {
 7479    bool retval = true;
 7480    retval = algo::StripTypeTag(in_str, "fasttest.SampleSetConst");
 7481    ind_beg(algo::Attr_curs, attr, in_str) {
 7482        retval = retval && SampleSetConst_ReadFieldMaybe(parent, attr.name, attr.value);
 7483    }ind_end;
 7484    return retval;
 7485}
 7486
 7487// --- fasttest.SampleSetConst..Print
 7488// print string representation of ROW to string STR
 7489// cfmt:fasttest.SampleSetConst.String  printfmt:Tuple
 7490void fasttest::SampleSetConst_Print(fasttest::SampleSetConst& row, algo::cstring& str) {
 7491    algo::tempstr temp;
 7492    str << "fasttest.SampleSetConst";
 7493
 7494    fasttest::SampleSet_Print(Value_Get(row), temp);
 7495    PrintAttrSpaceReset(str,"Value", temp);
 7496}
 7497
 7498// --- fasttest.SampleSetConst..FastEncode
 7499void fasttest::SampleSetConst_FastEncode(algo::ByteAry& buf, FastState& state, fasttest::SampleSetConst& parent) {
 7500    int index = ary_N(buf);
 7501    u64 pmap(0);
 7502    if (!tid_AssignedQ(state) || parent.id != state.tid) {
 7503        lib_fast::EncodeUnsigned(buf,parent.id,false);
 7504        lib_fast::SetPmapBit(pmap,0);
 7505    }
 7506    tid_SetAssigned(state);
 7507    state.tid = parent.id;
 7508    // Value type constant mandatory
 7509    lib_fast::InsertPmap(buf,index,pmap);
 7510}
 7511
 7512// --- fasttest.SampleSetConst..FastDecode
 7513bool fasttest::SampleSetConst_FastDecode(algo::memptr& from, u64 pmap, FastState& state, fasttest::SampleSetConst& parent) {
 7514    bool ok = true;
 7515    // Value type constant mandatory
 7516    if (ok) {
 7517    }
 7518    (void)from;//only to avoid -Wunused-parameter
 7519    (void)pmap;//only to avoid -Wunused-parameter
 7520    (void)state;//only to avoid -Wunused-parameter
 7521    (void)parent;//only to avoid -Wunused-parameter
 7522    return ok;
 7523}
 7524
 7525// --- fasttest.SampleSetConst..FixEncode
 7526void fasttest::SampleSetConst_FixEncode(cstring& buf, fasttest::SampleSetConst& parent, char soh) {
 7527    buf << "1=" << Value_Get(parent) << soh;
 7528}
 7529
 7530// --- fasttest.SampleSetCopy.base.CopyOut
 7531// Copy fields out of row
 7532void fasttest::parent_CopyOut(fasttest::SampleSetCopy &row, fasttest::TemplateHeader &out) {
 7533    // length: field value is computed
 7534    // id: field value is computed
 7535    (void)row;//only to avoid -Wunused-parameter
 7536    (void)out;//only to avoid -Wunused-parameter
 7537}
 7538
 7539// --- fasttest.SampleSetCopy..ReadFieldMaybe
 7540bool fasttest::SampleSetCopy_ReadFieldMaybe(fasttest::SampleSetCopy& parent, algo::strptr field, algo::strptr strval) {
 7541    bool retval = true;
 7542    fasttest::FieldId field_id;
 7543    (void)value_SetStrptrMaybe(field_id,field);
 7544    switch(field_id) {
 7545        case fasttest_FieldId_base: {
 7546            retval = false;
 7547            break;
 7548        }
 7549        case fasttest_FieldId_length: {
 7550            retval = false;
 7551            break;
 7552        }
 7553        case fasttest_FieldId_id: {
 7554            retval = false;
 7555            break;
 7556        }
 7557        case fasttest_FieldId_Value150: {
 7558            retval = fasttest::SampleSet_ReadStrptrMaybe(parent.Value150, strval);
 7559            break;
 7560        }
 7561        default: break;
 7562    }
 7563    if (!retval) {
 7564        algo_lib::AppendErrtext("attr",field);
 7565    }
 7566    return retval;
 7567}
 7568
 7569// --- fasttest.SampleSetCopy..ReadStrptrMaybe
 7570// Read fields of fasttest::SampleSetCopy from an ascii string.
 7571// The format of the string is an ssim Tuple
 7572bool fasttest::SampleSetCopy_ReadStrptrMaybe(fasttest::SampleSetCopy &parent, algo::strptr in_str) {
 7573    bool retval = true;
 7574    retval = algo::StripTypeTag(in_str, "fasttest.SampleSetCopy");
 7575    ind_beg(algo::Attr_curs, attr, in_str) {
 7576        retval = retval && SampleSetCopy_ReadFieldMaybe(parent, attr.name, attr.value);
 7577    }ind_end;
 7578    return retval;
 7579}
 7580
 7581// --- fasttest.SampleSetCopy..Print
 7582// print string representation of ROW to string STR
 7583// cfmt:fasttest.SampleSetCopy.String  printfmt:Tuple
 7584void fasttest::SampleSetCopy_Print(fasttest::SampleSetCopy& row, algo::cstring& str) {
 7585    algo::tempstr temp;
 7586    str << "fasttest.SampleSetCopy";
 7587
 7588    fasttest::SampleSet_Print(row.Value150, temp);
 7589    PrintAttrSpaceReset(str,"Value150", temp);
 7590}
 7591
 7592// --- fasttest.SampleSetCopy..FastEncode
 7593void fasttest::SampleSetCopy_FastEncode(algo::ByteAry& buf, FastState& state, fasttest::SampleSetCopy& parent) {
 7594    int index = ary_N(buf);
 7595    u64 pmap(0);
 7596    if (!tid_AssignedQ(state) || parent.id != state.tid) {
 7597        lib_fast::EncodeUnsigned(buf,parent.id,false);
 7598        lib_fast::SetPmapBit(pmap,0);
 7599    }
 7600    tid_SetAssigned(state);
 7601    state.tid = parent.id;
 7602    // Value150 type copy mandatory
 7603    if (Value150_AssignedQ(state) ? parent.Value150.value != state.Value150.value : parent.Value150.value != 2) {
 7604        lib_fast::EncodeUnsigned(buf,parent.Value150.value,false);
 7605        lib_fast::SetPmapBit(pmap,1);
 7606    }
 7607    state.Value150.value = parent.Value150.value;
 7608    Value150_SetAssigned(state);
 7609    lib_fast::InsertPmap(buf,index,pmap);
 7610}
 7611
 7612// --- fasttest.SampleSetCopy..FastDecode
 7613bool fasttest::SampleSetCopy_FastDecode(algo::memptr& from, u64 pmap, FastState& state, fasttest::SampleSetCopy& parent) {
 7614    bool ok = true;
 7615    // Value150 type copy mandatory
 7616    if (ok) {
 7617        bool prs = lib_fast::GetPmapBit(pmap,1);
 7618        if (prs) {
 7619            ok = lib_fast::DecodeUnsigned(from,parent.Value150.value,false);
 7620            if (!ok) {
 7621                state.error << "fasttest.SampleSetCopy.Value150: bad Unsigned" << eol;
 7622            }
 7623        } else if (Value150_AssignedQ(state)) {
 7624            parent.Value150.value = state.Value150.value;
 7625        } else {
 7626            parent.Value150.value = 2;
 7627        }
 7628        Value150_SetAssigned(state);
 7629        state.Value150.value = parent.Value150.value;
 7630    }
 7631    return ok;
 7632}
 7633
 7634// --- fasttest.SampleSetCopy..FixEncode
 7635void fasttest::SampleSetCopy_FixEncode(cstring& buf, fasttest::SampleSetCopy& parent, char soh) {
 7636    buf << "1=" << parent.Value150 << soh;
 7637}
 7638
 7639// --- fasttest.SampleSetDefault.base.CopyOut
 7640// Copy fields out of row
 7641void fasttest::parent_CopyOut(fasttest::SampleSetDefault &row, fasttest::TemplateHeader &out) {
 7642    // length: field value is computed
 7643    // id: field value is computed
 7644    (void)row;//only to avoid -Wunused-parameter
 7645    (void)out;//only to avoid -Wunused-parameter
 7646}
 7647
 7648// --- fasttest.SampleSetDefault..ReadFieldMaybe
 7649bool fasttest::SampleSetDefault_ReadFieldMaybe(fasttest::SampleSetDefault& parent, algo::strptr field, algo::strptr strval) {
 7650    bool retval = true;
 7651    fasttest::FieldId field_id;
 7652    (void)value_SetStrptrMaybe(field_id,field);
 7653    switch(field_id) {
 7654        case fasttest_FieldId_base: {
 7655            retval = false;
 7656            break;
 7657        }
 7658        case fasttest_FieldId_length: {
 7659            retval = false;
 7660            break;
 7661        }
 7662        case fasttest_FieldId_id: {
 7663            retval = false;
 7664            break;
 7665        }
 7666        case fasttest_FieldId_Value: {
 7667            retval = fasttest::SampleSet_ReadStrptrMaybe(parent.Value, strval);
 7668            break;
 7669        }
 7670        default: break;
 7671    }
 7672    if (!retval) {
 7673        algo_lib::AppendErrtext("attr",field);
 7674    }
 7675    return retval;
 7676}
 7677
 7678// --- fasttest.SampleSetDefault..ReadStrptrMaybe
 7679// Read fields of fasttest::SampleSetDefault from an ascii string.
 7680// The format of the string is an ssim Tuple
 7681bool fasttest::SampleSetDefault_ReadStrptrMaybe(fasttest::SampleSetDefault &parent, algo::strptr in_str) {
 7682    bool retval = true;
 7683    retval = algo::StripTypeTag(in_str, "fasttest.SampleSetDefault");
 7684    ind_beg(algo::Attr_curs, attr, in_str) {
 7685        retval = retval && SampleSetDefault_ReadFieldMaybe(parent, attr.name, attr.value);
 7686    }ind_end;
 7687    return retval;
 7688}
 7689
 7690// --- fasttest.SampleSetDefault..Print
 7691// print string representation of ROW to string STR
 7692// cfmt:fasttest.SampleSetDefault.String  printfmt:Tuple
 7693void fasttest::SampleSetDefault_Print(fasttest::SampleSetDefault& row, algo::cstring& str) {
 7694    algo::tempstr temp;
 7695    str << "fasttest.SampleSetDefault";
 7696
 7697    fasttest::SampleSet_Print(row.Value, temp);
 7698    PrintAttrSpaceReset(str,"Value", temp);
 7699}
 7700
 7701// --- fasttest.SampleSetDefault..FastEncode
 7702void fasttest::SampleSetDefault_FastEncode(algo::ByteAry& buf, FastState& state, fasttest::SampleSetDefault& parent) {
 7703    int index = ary_N(buf);
 7704    u64 pmap(0);
 7705    if (!tid_AssignedQ(state) || parent.id != state.tid) {
 7706        lib_fast::EncodeUnsigned(buf,parent.id,false);
 7707        lib_fast::SetPmapBit(pmap,0);
 7708    }
 7709    tid_SetAssigned(state);
 7710    state.tid = parent.id;
 7711    // Value type default mandatory
 7712    if (parent.Value.value != 3) {
 7713        lib_fast::EncodeUnsigned(buf,parent.Value.value,false);
 7714        lib_fast::SetPmapBit(pmap,1);
 7715    }
 7716    lib_fast::InsertPmap(buf,index,pmap);
 7717}
 7718
 7719// --- fasttest.SampleSetDefault..FastDecode
 7720bool fasttest::SampleSetDefault_FastDecode(algo::memptr& from, u64 pmap, FastState& state, fasttest::SampleSetDefault& parent) {
 7721    bool ok = true;
 7722    // Value type default mandatory
 7723    if (ok) {
 7724        bool prs = lib_fast::GetPmapBit(pmap,1);
 7725        if (prs) {
 7726            ok = lib_fast::DecodeUnsigned(from,parent.Value.value,false);
 7727            if (!ok) {
 7728                state.error << "fasttest.SampleSetDefault.Value: bad Unsigned" << eol;
 7729            }
 7730        } else {
 7731            parent.Value.value = 3;
 7732        }
 7733    }
 7734    return ok;
 7735}
 7736
 7737// --- fasttest.SampleSetDefault..FixEncode
 7738void fasttest::SampleSetDefault_FixEncode(cstring& buf, fasttest::SampleSetDefault& parent, char soh) {
 7739    buf << "1=" << parent.Value << soh;
 7740}
 7741
 7742// --- fasttest.SclConst.base.CopyOut
 7743// Copy fields out of row
 7744void fasttest::parent_CopyOut(fasttest::SclConst &row, fasttest::TemplateHeader &out) {
 7745    // length: field value is computed
 7746    // id: field value is computed
 7747    (void)row;//only to avoid -Wunused-parameter
 7748    (void)out;//only to avoid -Wunused-parameter
 7749}
 7750
 7751// --- fasttest.SclConst..ReadFieldMaybe
 7752bool fasttest::SclConst_ReadFieldMaybe(fasttest::SclConst& parent, algo::strptr field, algo::strptr strval) {
 7753    bool retval = true;
 7754    fasttest::FieldId field_id;
 7755    (void)value_SetStrptrMaybe(field_id,field);
 7756    switch(field_id) {
 7757        case fasttest_FieldId_base: {
 7758            retval = false;
 7759            break;
 7760        }
 7761        case fasttest_FieldId_length: {
 7762            retval = false;
 7763            break;
 7764        }
 7765        case fasttest_FieldId_id: {
 7766            retval = false;
 7767            break;
 7768        }
 7769        case fasttest_FieldId_Value: {
 7770            retval = true;
 7771            break;
 7772        }
 7773        default: break;
 7774    }
 7775    if (!retval) {
 7776        algo_lib::AppendErrtext("attr",field);
 7777    }
 7778    (void)parent;//only to avoid -Wunused-parameter
 7779    (void)strval;//only to avoid -Wunused-parameter
 7780    return retval;
 7781}
 7782
 7783// --- fasttest.SclConst..ReadStrptrMaybe
 7784// Read fields of fasttest::SclConst from an ascii string.
 7785// The format of the string is an ssim Tuple
 7786bool fasttest::SclConst_ReadStrptrMaybe(fasttest::SclConst &parent, algo::strptr in_str) {
 7787    bool retval = true;
 7788    retval = algo::StripTypeTag(in_str, "fasttest.SclConst");
 7789    ind_beg(algo::Attr_curs, attr, in_str) {
 7790        retval = retval && SclConst_ReadFieldMaybe(parent, attr.name, attr.value);
 7791    }ind_end;
 7792    return retval;
 7793}
 7794
 7795// --- fasttest.SclConst..Print
 7796// print string representation of ROW to string STR
 7797// cfmt:fasttest.SclConst.String  printfmt:Tuple
 7798void fasttest::SclConst_Print(fasttest::SclConst& row, algo::cstring& str) {
 7799    algo::tempstr temp;
 7800    str << "fasttest.SclConst";
 7801
 7802    algo::Decimal_Print(Value_Get(row), temp);
 7803    PrintAttrSpaceReset(str,"Value", temp);
 7804}
 7805
 7806// --- fasttest.SclConst..FastEncode
 7807void fasttest::SclConst_FastEncode(algo::ByteAry& buf, FastState& state, fasttest::SclConst& parent) {
 7808    int index = ary_N(buf);
 7809    u64 pmap(0);
 7810    if (!tid_AssignedQ(state) || parent.id != state.tid) {
 7811        lib_fast::EncodeUnsigned(buf,parent.id,false);
 7812        lib_fast::SetPmapBit(pmap,0);
 7813    }
 7814    tid_SetAssigned(state);
 7815    state.tid = parent.id;
 7816    // Value scaled constant mandatory
 7817    lib_fast::InsertPmap(buf,index,pmap);
 7818}
 7819
 7820// --- fasttest.SclConst..FastDecode
 7821bool fasttest::SclConst_FastDecode(algo::memptr& from, u64 pmap, FastState& state, fasttest::SclConst& parent) {
 7822    bool ok = true;
 7823    // Value scaled constant mandatory
 7824    if (ok) {
 7825    }
 7826    (void)from;//only to avoid -Wunused-parameter
 7827    (void)pmap;//only to avoid -Wunused-parameter
 7828    (void)state;//only to avoid -Wunused-parameter
 7829    (void)parent;//only to avoid -Wunused-parameter
 7830    return ok;
 7831}
 7832
 7833// --- fasttest.SclConst..FixEncode
 7834void fasttest::SclConst_FixEncode(cstring& buf, fasttest::SclConst& parent, char soh) {
 7835    buf << "1=" << Value_Get(parent) << soh;
 7836}
 7837
 7838// --- fasttest.SclConstOpt.base.CopyOut
 7839// Copy fields out of row
 7840void fasttest::parent_CopyOut(fasttest::SclConstOpt &row, fasttest::TemplateHeader &out) {
 7841    // length: field value is computed
 7842    // id: field value is computed
 7843    (void)row;//only to avoid -Wunused-parameter
 7844    (void)out;//only to avoid -Wunused-parameter
 7845}
 7846
 7847// --- fasttest.SclConstOpt.pmask_bitcurs.Next
 7848// proceed to next item
 7849void fasttest::SclConstOpt_pmask_bitcurs_Next(SclConstOpt_pmask_bitcurs &curs) {
 7850    ++curs.bit;
 7851    int index = curs.bit / 32;
 7852    int offset = curs.bit % 32;
 7853    for (; index < curs.n_elems; ++index, offset = 0) {
 7854        u64 rest = curs.elems[index] >> offset;
 7855        if (rest) {
 7856            offset += algo::u64_BitScanForward(rest);
 7857            break;
 7858        }
 7859    }
 7860    curs.bit = index * 32 + offset;
 7861}
 7862
 7863// --- fasttest.SclConstOpt..ReadFieldMaybe
 7864bool fasttest::SclConstOpt_ReadFieldMaybe(fasttest::SclConstOpt& parent, algo::strptr field, algo::strptr strval) {
 7865    bool retval = true;
 7866    fasttest::FieldId field_id;
 7867    (void)value_SetStrptrMaybe(field_id,field);
 7868    switch(field_id) {
 7869        case fasttest_FieldId_base: {
 7870            retval = false;
 7871            break;
 7872        }
 7873        case fasttest_FieldId_length: {
 7874            retval = false;
 7875            break;
 7876        }
 7877        case fasttest_FieldId_id: {
 7878            retval = false;
 7879            break;
 7880        }
 7881        case fasttest_FieldId_pmask: {
 7882            retval = false;
 7883            break;
 7884        }
 7885        case fasttest_FieldId_Value: {
 7886            retval = true;
 7887            if (retval) {
 7888                pmask_qSetBit(parent, 0);
 7889            }
 7890            break;
 7891        }
 7892        default: break;
 7893    }
 7894    if (!retval) {
 7895        algo_lib::AppendErrtext("attr",field);
 7896    }
 7897    (void)strval;//only to avoid -Wunused-parameter
 7898    return retval;
 7899}
 7900
 7901// --- fasttest.SclConstOpt..ReadStrptrMaybe
 7902// Read fields of fasttest::SclConstOpt from an ascii string.
 7903// The format of the string is an ssim Tuple
 7904bool fasttest::SclConstOpt_ReadStrptrMaybe(fasttest::SclConstOpt &parent, algo::strptr in_str) {
 7905    bool retval = true;
 7906    retval = algo::StripTypeTag(in_str, "fasttest.SclConstOpt");
 7907    ind_beg(algo::Attr_curs, attr, in_str) {
 7908        retval = retval && SclConstOpt_ReadFieldMaybe(parent, attr.name, attr.value);
 7909    }ind_end;
 7910    return retval;
 7911}
 7912
 7913// --- fasttest.SclConstOpt..Print
 7914// print string representation of ROW to string STR
 7915// cfmt:fasttest.SclConstOpt.String  printfmt:Tuple
 7916void fasttest::SclConstOpt_Print(fasttest::SclConstOpt& row, algo::cstring& str) {
 7917    algo::tempstr temp;
 7918    str << "fasttest.SclConstOpt";
 7919
 7920    if (Value_PresentQ(row)) {
 7921        algo::Decimal_Print(Value_Get(row), temp);
 7922        PrintAttrSpaceReset(str,"Value", temp);
 7923    }
 7924}
 7925
 7926// --- fasttest.SclConstOpt..FastEncode
 7927void fasttest::SclConstOpt_FastEncode(algo::ByteAry& buf, FastState& state, fasttest::SclConstOpt& parent) {
 7928    int index = ary_N(buf);
 7929    u64 pmap(0);
 7930    if (!tid_AssignedQ(state) || parent.id != state.tid) {
 7931        lib_fast::EncodeUnsigned(buf,parent.id,false);
 7932        lib_fast::SetPmapBit(pmap,0);
 7933    }
 7934    tid_SetAssigned(state);
 7935    state.tid = parent.id;
 7936    // Value scaled constant optional
 7937    if (Value_PresentQ(parent)) {
 7938        lib_fast::SetPmapBit(pmap,1);
 7939    }
 7940    lib_fast::InsertPmap(buf,index,pmap);
 7941}
 7942
 7943// --- fasttest.SclConstOpt..FastDecode
 7944bool fasttest::SclConstOpt_FastDecode(algo::memptr& from, u64 pmap, FastState& state, fasttest::SclConstOpt& parent) {
 7945    bool ok = true;
 7946    // Value scaled constant optional
 7947    if (ok) {
 7948        bool prs = lib_fast::GetPmapBit(pmap,1);
 7949        pmask_qSetBitVal(parent,Value_Present_GetBit(parent),prs);
 7950    }
 7951    (void)from;//only to avoid -Wunused-parameter
 7952    (void)state;//only to avoid -Wunused-parameter
 7953    return ok;
 7954}
 7955
 7956// --- fasttest.SclConstOpt..FixEncode
 7957void fasttest::SclConstOpt_FixEncode(cstring& buf, fasttest::SclConstOpt& parent, char soh) {
 7958    if (Value_PresentQ(parent)) {
 7959        buf << "1=" << Value_Get(parent) << soh;
 7960    }
 7961}
 7962
 7963// --- fasttest.SclCopy.base.CopyOut
 7964// Copy fields out of row
 7965void fasttest::parent_CopyOut(fasttest::SclCopy &row, fasttest::TemplateHeader &out) {
 7966    // length: field value is computed
 7967    // id: field value is computed
 7968    (void)row;//only to avoid -Wunused-parameter
 7969    (void)out;//only to avoid -Wunused-parameter
 7970}
 7971
 7972// --- fasttest.SclCopy..ReadFieldMaybe
 7973bool fasttest::SclCopy_ReadFieldMaybe(fasttest::SclCopy& parent, algo::strptr field, algo::strptr strval) {
 7974    bool retval = true;
 7975    fasttest::FieldId field_id;
 7976    (void)value_SetStrptrMaybe(field_id,field);
 7977    switch(field_id) {
 7978        case fasttest_FieldId_base: {
 7979            retval = false;
 7980            break;
 7981        }
 7982        case fasttest_FieldId_length: {
 7983            retval = false;
 7984            break;
 7985        }
 7986        case fasttest_FieldId_id: {
 7987            retval = false;
 7988            break;
 7989        }
 7990        case fasttest_FieldId_Value61: {
 7991            retval = algo::Decimal_ReadStrptrMaybe(parent.Value61, strval);
 7992            break;
 7993        }
 7994        default: break;
 7995    }
 7996    if (!retval) {
 7997        algo_lib::AppendErrtext("attr",field);
 7998    }
 7999    return retval;
 8000}
 8001
 8002// --- fasttest.SclCopy..ReadStrptrMaybe
 8003// Read fields of fasttest::SclCopy from an ascii string.
 8004// The format of the string is an ssim Tuple
 8005bool fasttest::SclCopy_ReadStrptrMaybe(fasttest::SclCopy &parent, algo::strptr in_str) {
 8006    bool retval = true;
 8007    retval = algo::StripTypeTag(in_str, "fasttest.SclCopy");
 8008    ind_beg(algo::Attr_curs, attr, in_str) {
 8009        retval = retval && SclCopy_ReadFieldMaybe(parent, attr.name, attr.value);
 8010    }ind_end;
 8011    return retval;
 8012}
 8013
 8014// --- fasttest.SclCopy..Print
 8015// print string representation of ROW to string STR
 8016// cfmt:fasttest.SclCopy.String  printfmt:Tuple
 8017void fasttest::SclCopy_Print(fasttest::SclCopy& row, algo::cstring& str) {
 8018    algo::tempstr temp;
 8019    str << "fasttest.SclCopy";
 8020
 8021    algo::Decimal_Print(row.Value61, temp);
 8022    PrintAttrSpaceReset(str,"Value61", temp);
 8023}
 8024
 8025// --- fasttest.SclCopy..FastEncode
 8026void fasttest::SclCopy_FastEncode(algo::ByteAry& buf, FastState& state, fasttest::SclCopy& parent) {
 8027    int index = ary_N(buf);
 8028    u64 pmap(0);
 8029    if (!tid_AssignedQ(state) || parent.id != state.tid) {
 8030        lib_fast::EncodeUnsigned(buf,parent.id,false);
 8031        lib_fast::SetPmapBit(pmap,0);
 8032    }
 8033    tid_SetAssigned(state);
 8034    state.tid = parent.id;
 8035    // Value61 scaled copy mandatory
 8036    if (Value61_AssignedQ(state) ? parent.Value61 != state.Value61 : parent.Value61 != algo::Decimal(-2,-61)) {
 8037        lib_fast::EncodeScaled(buf,parent.Value61,false);
 8038        lib_fast::SetPmapBit(pmap,1);
 8039    }
 8040    state.Value61 = parent.Value61;
 8041    Value61_SetAssigned(state);
 8042    lib_fast::InsertPmap(buf,index,pmap);
 8043}
 8044
 8045// --- fasttest.SclCopy..FastDecode
 8046bool fasttest::SclCopy_FastDecode(algo::memptr& from, u64 pmap, FastState& state, fasttest::SclCopy& parent) {
 8047    bool ok = true;
 8048    // Value61 scaled copy mandatory
 8049    if (ok) {
 8050        bool prs = lib_fast::GetPmapBit(pmap,1);
 8051        if (prs) {
 8052            ok = lib_fast::DecodeScaled(from,parent.Value61,false);
 8053            if (!ok) {
 8054                state.error << "fasttest.SclCopy.Value61: bad Scaled" << eol;
 8055            }
 8056        } else if (Value61_AssignedQ(state)) {
 8057            parent.Value61 = state.Value61;
 8058        } else {
 8059            parent.Value61 = algo::Decimal(-2,-61);
 8060        }
 8061        Value61_SetAssigned(state);
 8062        state.Value61 = parent.Value61;
 8063    }
 8064    return ok;
 8065}
 8066
 8067// --- fasttest.SclCopy..FixEncode
 8068void fasttest::SclCopy_FixEncode(cstring& buf, fasttest::SclCopy& parent, char soh) {
 8069    buf << "1=" << parent.Value61 << soh;
 8070}
 8071
 8072// --- fasttest.SclCopyNull.base.CopyOut
 8073// Copy fields out of row
 8074void fasttest::parent_CopyOut(fasttest::SclCopyNull &row, fasttest::TemplateHeader &out) {
 8075    // length: field value is computed
 8076    // id: field value is computed
 8077    (void)row;//only to avoid -Wunused-parameter
 8078    (void)out;//only to avoid -Wunused-parameter
 8079}
 8080
 8081// --- fasttest.SclCopyNull.Value63.ReadStrptrMaybe
 8082inline static bool fasttest::Value63_ReadStrptrMaybe(fasttest::SclCopyNull &parent, algo::strptr in_str) {
 8083    bool retval = true;
 8084    algo::Decimal Value63_tmp;
 8085    retval = algo::Decimal_ReadStrptrMaybe(Value63_tmp, in_str);
 8086    if (retval) {
 8087        Value63_Set(parent, Value63_tmp);
 8088    }
 8089    return retval;
 8090}
 8091
 8092// --- fasttest.SclCopyNull.pmask_bitcurs.Next
 8093// proceed to next item
 8094void fasttest::SclCopyNull_pmask_bitcurs_Next(SclCopyNull_pmask_bitcurs &curs) {
 8095    ++curs.bit;
 8096    int index = curs.bit / 32;
 8097    int offset = curs.bit % 32;
 8098    for (; index < curs.n_elems; ++index, offset = 0) {
 8099        u64 rest = curs.elems[index] >> offset;
 8100        if (rest) {
 8101            offset += algo::u64_BitScanForward(rest);
 8102            break;
 8103        }
 8104    }
 8105    curs.bit = index * 32 + offset;
 8106}
 8107
 8108// --- fasttest.SclCopyNull..ReadFieldMaybe
 8109bool fasttest::SclCopyNull_ReadFieldMaybe(fasttest::SclCopyNull& parent, algo::strptr field, algo::strptr strval) {
 8110    bool retval = true;
 8111    fasttest::FieldId field_id;
 8112    (void)value_SetStrptrMaybe(field_id,field);
 8113    switch(field_id) {
 8114        case fasttest_FieldId_base: {
 8115            retval = false;
 8116            break;
 8117        }
 8118        case fasttest_FieldId_length: {
 8119            retval = false;
 8120            break;
 8121        }
 8122        case fasttest_FieldId_id: {
 8123            retval = false;
 8124            break;
 8125        }
 8126        case fasttest_FieldId_pmask: {
 8127            retval = false;
 8128            break;
 8129        }
 8130        case fasttest_FieldId_Value63: {
 8131            retval = Value63_ReadStrptrMaybe(parent, strval);
 8132            if (retval) {
 8133                pmask_qSetBit(parent, 0);
 8134            }
 8135            break;
 8136        }
 8137        default: break;
 8138    }
 8139    if (!retval) {
 8140        algo_lib::AppendErrtext("attr",field);
 8141    }
 8142    return retval;
 8143}
 8144
 8145// --- fasttest.SclCopyNull..ReadStrptrMaybe
 8146// Read fields of fasttest::SclCopyNull from an ascii string.
 8147// The format of the string is an ssim Tuple
 8148bool fasttest::SclCopyNull_ReadStrptrMaybe(fasttest::SclCopyNull &parent, algo::strptr in_str) {
 8149    bool retval = true;
 8150    retval = algo::StripTypeTag(in_str, "fasttest.SclCopyNull");
 8151    ind_beg(algo::Attr_curs, attr, in_str) {
 8152        retval = retval && SclCopyNull_ReadFieldMaybe(parent, attr.name, attr.value);
 8153    }ind_end;
 8154    return retval;
 8155}
 8156
 8157// --- fasttest.SclCopyNull..Print
 8158// print string representation of ROW to string STR
 8159// cfmt:fasttest.SclCopyNull.String  printfmt:Tuple
 8160void fasttest::SclCopyNull_Print(fasttest::SclCopyNull& row, algo::cstring& str) {
 8161    algo::tempstr temp;
 8162    str << "fasttest.SclCopyNull";
 8163
 8164    if (Value63_PresentQ(row)) {
 8165        algo::Decimal_Print(row.Value63, temp);
 8166        PrintAttrSpaceReset(str,"Value63", temp);
 8167    }
 8168}
 8169
 8170// --- fasttest.SclCopyNull..FastEncode
 8171void fasttest::SclCopyNull_FastEncode(algo::ByteAry& buf, FastState& state, fasttest::SclCopyNull& parent) {
 8172    int index = ary_N(buf);
 8173    u64 pmap(0);
 8174    if (!tid_AssignedQ(state) || parent.id != state.tid) {
 8175        lib_fast::EncodeUnsigned(buf,parent.id,false);
 8176        lib_fast::SetPmapBit(pmap,0);
 8177    }
 8178    tid_SetAssigned(state);
 8179    state.tid = parent.id;
 8180    // Value63 scaled copy optional
 8181    if (Value63_PresentQ(parent)) {
 8182        if (Value63_AssignedQ(state) ? !Value63_PresentQ(state) || parent.Value63 != state.Value63 : parent.Value63 != algo::Decimal(0,0)) {
 8183            lib_fast::EncodeScaled(buf,parent.Value63,true);
 8184            lib_fast::SetPmapBit(pmap,1);
 8185        }
 8186    } else {
 8187        if (Value63_AssignedQ(state) && Value63_PresentQ(state)) {
 8188            lib_fast::EncodeNull(buf);
 8189            lib_fast::SetPmapBit(pmap,1);
 8190        }
 8191    }
 8192    state.Value63 = parent.Value63;
 8193    present_qSetBitVal(state,Value63_Present_GetBit(state),Value63_PresentQ(parent));
 8194    Value63_SetAssigned(state);
 8195    lib_fast::InsertPmap(buf,index,pmap);
 8196}
 8197
 8198// --- fasttest.SclCopyNull..FastDecode
 8199bool fasttest::SclCopyNull_FastDecode(algo::memptr& from, u64 pmap, FastState& state, fasttest::SclCopyNull& parent) {
 8200    bool ok = true;
 8201    // Value63 scaled copy optional
 8202    if (ok) {
 8203        bool prs = lib_fast::GetPmapBit(pmap,1);
 8204        if (prs) {
 8205            prs = !lib_fast::DecodeNull(from);
 8206            if (prs) {
 8207                ok = lib_fast::DecodeScaled(from,parent.Value63,true);
 8208                if (!ok) {
 8209                    state.error << "fasttest.SclCopyNull.Value63: bad Scaled" << eol;
 8210                }
 8211            }
 8212        } else if (Value63_AssignedQ(state)) {
 8213            parent.Value63 = state.Value63;
 8214            prs = Value63_PresentQ(state);
 8215        } else {
 8216            parent.Value63 = algo::Decimal(0,0);
 8217            prs = true;
 8218        }
 8219        pmask_qSetBitVal(parent,Value63_Present_GetBit(parent),prs);
 8220        Value63_SetAssigned(state);
 8221        present_qSetBitVal(state,Value63_Present_GetBit(state),prs);
 8222        state.Value63 = parent.Value63;
 8223    }
 8224    return ok;
 8225}
 8226
 8227// --- fasttest.SclCopyNull..FixEncode
 8228void fasttest::SclCopyNull_FixEncode(cstring& buf, fasttest::SclCopyNull& parent, char soh) {
 8229    if (Value63_PresentQ(parent)) {
 8230        buf << "1=" << parent.Value63 << soh;
 8231    }
 8232}
 8233
 8234// --- fasttest.SclCopyOpt.base.CopyOut
 8235// Copy fields out of row
 8236void fasttest::parent_CopyOut(fasttest::SclCopyOpt &row, fasttest::TemplateHeader &out) {
 8237    // length: field value is computed
 8238    // id: field value is computed
 8239    (void)row;//only to avoid -Wunused-parameter
 8240    (void)out;//only to avoid -Wunused-parameter
 8241}
 8242
 8243// --- fasttest.SclCopyOpt.Value62.ReadStrptrMaybe
 8244inline static bool fasttest::Value62_ReadStrptrMaybe(fasttest::SclCopyOpt &parent, algo::strptr in_str) {
 8245    bool retval = true;
 8246    algo::Decimal Value62_tmp;
 8247    retval = algo::Decimal_ReadStrptrMaybe(Value62_tmp, in_str);
 8248    if (retval) {
 8249        Value62_Set(parent, Value62_tmp);
 8250    }
 8251    return retval;
 8252}
 8253
 8254// --- fasttest.SclCopyOpt.pmask_bitcurs.Next
 8255// proceed to next item
 8256void fasttest::SclCopyOpt_pmask_bitcurs_Next(SclCopyOpt_pmask_bitcurs &curs) {
 8257    ++curs.bit;
 8258    int index = curs.bit / 32;
 8259    int offset = curs.bit % 32;
 8260    for (; index < curs.n_elems; ++index, offset = 0) {
 8261        u64 rest = curs.elems[index] >> offset;
 8262        if (rest) {
 8263            offset += algo::u64_BitScanForward(rest);
 8264            break;
 8265        }
 8266    }
 8267    curs.bit = index * 32 + offset;
 8268}
 8269
 8270// --- fasttest.SclCopyOpt..ReadFieldMaybe
 8271bool fasttest::SclCopyOpt_ReadFieldMaybe(fasttest::SclCopyOpt& parent, algo::strptr field, algo::strptr strval) {
 8272    bool retval = true;
 8273    fasttest::FieldId field_id;
 8274    (void)value_SetStrptrMaybe(field_id,field);
 8275    switch(field_id) {
 8276        case fasttest_FieldId_base: {
 8277            retval = false;
 8278            break;
 8279        }
 8280        case fasttest_FieldId_length: {
 8281            retval = false;
 8282            break;
 8283        }
 8284        case fasttest_FieldId_id: {
 8285            retval = false;
 8286            break;
 8287        }
 8288        case fasttest_FieldId_pmask: {
 8289            retval = false;
 8290            break;
 8291        }
 8292        case fasttest_FieldId_Value62: {
 8293            retval = Value62_ReadStrptrMaybe(parent, strval);
 8294            if (retval) {
 8295                pmask_qSetBit(parent, 0);
 8296            }
 8297            break;
 8298        }
 8299        default: break;
 8300    }
 8301    if (!retval) {
 8302        algo_lib::AppendErrtext("attr",field);
 8303    }
 8304    return retval;
 8305}
 8306
 8307// --- fasttest.SclCopyOpt..ReadStrptrMaybe
 8308// Read fields of fasttest::SclCopyOpt from an ascii string.
 8309// The format of the string is an ssim Tuple
 8310bool fasttest::SclCopyOpt_ReadStrptrMaybe(fasttest::SclCopyOpt &parent, algo::strptr in_str) {
 8311    bool retval = true;
 8312    retval = algo::StripTypeTag(in_str, "fasttest.SclCopyOpt");
 8313    ind_beg(algo::Attr_curs, attr, in_str) {
 8314        retval = retval && SclCopyOpt_ReadFieldMaybe(parent, attr.name, attr.value);
 8315    }ind_end;
 8316    return retval;
 8317}
 8318
 8319// --- fasttest.SclCopyOpt..Print
 8320// print string representation of ROW to string STR
 8321// cfmt:fasttest.SclCopyOpt.String  printfmt:Tuple
 8322void fasttest::SclCopyOpt_Print(fasttest::SclCopyOpt& row, algo::cstring& str) {
 8323    algo::tempstr temp;
 8324    str << "fasttest.SclCopyOpt";
 8325
 8326    if (Value62_PresentQ(row)) {
 8327        algo::Decimal_Print(row.Value62, temp);
 8328        PrintAttrSpaceReset(str,"Value62", temp);
 8329    }
 8330}
 8331
 8332// --- fasttest.SclCopyOpt..FastEncode
 8333void fasttest::SclCopyOpt_FastEncode(algo::ByteAry& buf, FastState& state, fasttest::SclCopyOpt& parent) {
 8334    int index = ary_N(buf);
 8335    u64 pmap(0);
 8336    if (!tid_AssignedQ(state) || parent.id != state.tid) {
 8337        lib_fast::EncodeUnsigned(buf,parent.id,false);
 8338        lib_fast::SetPmapBit(pmap,0);
 8339    }
 8340    tid_SetAssigned(state);
 8341    state.tid = parent.id;
 8342    // Value62 scaled copy optional
 8343    if (Value62_PresentQ(parent)) {
 8344        if (Value62_AssignedQ(state) ? !Value62_PresentQ(state) || parent.Value62 != state.Value62 : parent.Value62 != algo::Decimal(1,-62)) {
 8345            lib_fast::EncodeScaled(buf,parent.Value62,true);
 8346            lib_fast::SetPmapBit(pmap,1);
 8347        }
 8348    } else {
 8349        if (Value62_AssignedQ(state) && Value62_PresentQ(state)) {
 8350            lib_fast::EncodeNull(buf);
 8351            lib_fast::SetPmapBit(pmap,1);
 8352        }
 8353    }
 8354    state.Value62 = parent.Value62;
 8355    present_qSetBitVal(state,Value62_Present_GetBit(state),Value62_PresentQ(parent));
 8356    Value62_SetAssigned(state);
 8357    lib_fast::InsertPmap(buf,index,pmap);
 8358}
 8359
 8360// --- fasttest.SclCopyOpt..FastDecode
 8361bool fasttest::SclCopyOpt_FastDecode(algo::memptr& from, u64 pmap, FastState& state, fasttest::SclCopyOpt& parent) {
 8362    bool ok = true;
 8363    // Value62 scaled copy optional
 8364    if (ok) {
 8365        bool prs = lib_fast::GetPmapBit(pmap,1);
 8366        if (prs) {
 8367            prs = !lib_fast::DecodeNull(from);
 8368            if (prs) {
 8369                ok = lib_fast::DecodeScaled(from,parent.Value62,true);
 8370                if (!ok) {
 8371                    state.error << "fasttest.SclCopyOpt.Value62: bad Scaled" << eol;
 8372                }
 8373            }
 8374        } else if (Value62_AssignedQ(state)) {
 8375            parent.Value62 = state.Value62;
 8376            prs = Value62_PresentQ(state);
 8377        } else {
 8378            parent.Value62 = algo::Decimal(1,-62);
 8379            prs = true;
 8380        }
 8381        pmask_qSetBitVal(parent,Value62_Present_GetBit(parent),prs);
 8382        Value62_SetAssigned(state);
 8383        present_qSetBitVal(state,Value62_Present_GetBit(state),prs);
 8384        state.Value62 = parent.Value62;
 8385    }
 8386    return ok;
 8387}
 8388
 8389// --- fasttest.SclCopyOpt..FixEncode
 8390void fasttest::SclCopyOpt_FixEncode(cstring& buf, fasttest::SclCopyOpt& parent, char soh) {
 8391    if (Value62_PresentQ(parent)) {
 8392        buf << "1=" << parent.Value62 << soh;
 8393    }
 8394}
 8395
 8396// --- fasttest.SclDelta.base.CopyOut
 8397// Copy fields out of row
 8398void fasttest::parent_CopyOut(fasttest::SclDelta &row, fasttest::TemplateHeader &out) {
 8399    // length: field value is computed
 8400    // id: field value is computed
 8401    (void)row;//only to avoid -Wunused-parameter
 8402    (void)out;//only to avoid -Wunused-parameter
 8403}
 8404
 8405// --- fasttest.SclDelta..ReadFieldMaybe
 8406bool fasttest::SclDelta_ReadFieldMaybe(fasttest::SclDelta& parent, algo::strptr field, algo::strptr strval) {
 8407    bool retval = true;
 8408    fasttest::FieldId field_id;
 8409    (void)value_SetStrptrMaybe(field_id,field);
 8410    switch(field_id) {
 8411        case fasttest_FieldId_base: {
 8412            retval = false;
 8413            break;
 8414        }
 8415        case fasttest_FieldId_length: {
 8416            retval = false;
 8417            break;
 8418        }
 8419        case fasttest_FieldId_id: {
 8420            retval = false;
 8421            break;
 8422        }
 8423        case fasttest_FieldId_Value81: {
 8424            retval = algo::Decimal_ReadStrptrMaybe(parent.Value81, strval);
 8425            break;
 8426        }
 8427        default: break;
 8428    }
 8429    if (!retval) {
 8430        algo_lib::AppendErrtext("attr",field);
 8431    }
 8432    return retval;
 8433}
 8434
 8435// --- fasttest.SclDelta..ReadStrptrMaybe
 8436// Read fields of fasttest::SclDelta from an ascii string.
 8437// The format of the string is an ssim Tuple
 8438bool fasttest::SclDelta_ReadStrptrMaybe(fasttest::SclDelta &parent, algo::strptr in_str) {
 8439    bool retval = true;
 8440    retval = algo::StripTypeTag(in_str, "fasttest.SclDelta");
 8441    ind_beg(algo::Attr_curs, attr, in_str) {
 8442        retval = retval && SclDelta_ReadFieldMaybe(parent, attr.name, attr.value);
 8443    }ind_end;
 8444    return retval;
 8445}
 8446
 8447// --- fasttest.SclDelta..Print
 8448// print string representation of ROW to string STR
 8449// cfmt:fasttest.SclDelta.String  printfmt:Tuple
 8450void fasttest::SclDelta_Print(fasttest::SclDelta& row, algo::cstring& str) {
 8451    algo::tempstr temp;
 8452    str << "fasttest.SclDelta";
 8453
 8454    algo::Decimal_Print(row.Value81, temp);
 8455    PrintAttrSpaceReset(str,"Value81", temp);
 8456}
 8457
 8458// --- fasttest.SclDelta..FastEncode
 8459void fasttest::SclDelta_FastEncode(algo::ByteAry& buf, FastState& state, fasttest::SclDelta& parent) {
 8460    int index = ary_N(buf);
 8461    u64 pmap(0);
 8462    if (!tid_AssignedQ(state) || parent.id != state.tid) {
 8463        lib_fast::EncodeUnsigned(buf,parent.id,false);
 8464        lib_fast::SetPmapBit(pmap,0);
 8465    }
 8466    tid_SetAssigned(state);
 8467    state.tid = parent.id;
 8468    // Value81 scaled delta mandatory
 8469    if (!Value81_AssignedQ(state)) {
 8470        Value81_SetAssigned(state);
 8471        state.Value81 = algo::Decimal(-2,-81);
 8472    }
 8473    lib_fast::EncodeDeltaScaled(buf,state.Value81,parent.Value81,false);
 8474    state.Value81 = parent.Value81;
 8475    lib_fast::InsertPmap(buf,index,pmap);
 8476}
 8477
 8478// --- fasttest.SclDelta..FastDecode
 8479bool fasttest::SclDelta_FastDecode(algo::memptr& from, u64 pmap, FastState& state, fasttest::SclDelta& parent) {
 8480    bool ok = true;
 8481    // Value81 scaled delta mandatory
 8482    if (ok) {
 8483        if (!Value81_AssignedQ(state)) {
 8484            Value81_SetAssigned(state);
 8485            state.Value81 = algo::Decimal(-2,-81);
 8486        }
 8487        ok = lib_fast::DecodeDeltaScaled(from,state.Value81,parent.Value81,false);
 8488        if (!ok) {
 8489            state.error << "fasttest.SclDelta.Value81: bad Scaled delta" << eol;
 8490        }
 8491        state.Value81 = parent.Value81;
 8492    }
 8493    (void)pmap;//only to avoid -Wunused-parameter
 8494    return ok;
 8495}
 8496
 8497// --- fasttest.SclDelta..FixEncode
 8498void fasttest::SclDelta_FixEncode(cstring& buf, fasttest::SclDelta& parent, char soh) {
 8499    buf << "1=" << parent.Value81 << soh;
 8500}
 8501
 8502// --- fasttest.SclDeltaImpl.base.CopyOut
 8503// Copy fields out of row
 8504void fasttest::parent_CopyOut(fasttest::SclDeltaImpl &row, fasttest::TemplateHeader &out) {
 8505    // length: field value is computed
 8506    // id: field value is computed
 8507    (void)row;//only to avoid -Wunused-parameter
 8508    (void)out;//only to avoid -Wunused-parameter
 8509}
 8510
 8511// --- fasttest.SclDeltaImpl..ReadFieldMaybe
 8512bool fasttest::SclDeltaImpl_ReadFieldMaybe(fasttest::SclDeltaImpl& parent, algo::strptr field, algo::strptr strval) {
 8513    bool retval = true;
 8514    fasttest::FieldId field_id;
 8515    (void)value_SetStrptrMaybe(field_id,field);
 8516    switch(field_id) {
 8517        case fasttest_FieldId_base: {
 8518            retval = false;
 8519            break;
 8520        }
 8521        case fasttest_FieldId_length: {
 8522            retval = false;
 8523            break;
 8524        }
 8525        case fasttest_FieldId_id: {
 8526            retval = false;
 8527            break;
 8528        }
 8529        case fasttest_FieldId_Value82: {
 8530            retval = algo::Decimal_ReadStrptrMaybe(parent.Value82, strval);
 8531            break;
 8532        }
 8533        default: break;
 8534    }
 8535    if (!retval) {
 8536        algo_lib::AppendErrtext("attr",field);
 8537    }
 8538    return retval;
 8539}
 8540
 8541// --- fasttest.SclDeltaImpl..ReadStrptrMaybe
 8542// Read fields of fasttest::SclDeltaImpl from an ascii string.
 8543// The format of the string is an ssim Tuple
 8544bool fasttest::SclDeltaImpl_ReadStrptrMaybe(fasttest::SclDeltaImpl &parent, algo::strptr in_str) {
 8545    bool retval = true;
 8546    retval = algo::StripTypeTag(in_str, "fasttest.SclDeltaImpl");
 8547    ind_beg(algo::Attr_curs, attr, in_str) {
 8548        retval = retval && SclDeltaImpl_ReadFieldMaybe(parent, attr.name, attr.value);
 8549    }ind_end;
 8550    return retval;
 8551}
 8552
 8553// --- fasttest.SclDeltaImpl..Print
 8554// print string representation of ROW to string STR
 8555// cfmt:fasttest.SclDeltaImpl.String  printfmt:Tuple
 8556void fasttest::SclDeltaImpl_Print(fasttest::SclDeltaImpl& row, algo::cstring& str) {
 8557    algo::tempstr temp;
 8558    str << "fasttest.SclDeltaImpl";
 8559
 8560    algo::Decimal_Print(row.Value82, temp);
 8561    PrintAttrSpaceReset(str,"Value82", temp);
 8562}
 8563
 8564// --- fasttest.SclDeltaImpl..FastEncode
 8565void fasttest::SclDeltaImpl_FastEncode(algo::ByteAry& buf, FastState& state, fasttest::SclDeltaImpl& parent) {
 8566    int index = ary_N(buf);
 8567    u64 pmap(0);
 8568    if (!tid_AssignedQ(state) || parent.id != state.tid) {
 8569        lib_fast::EncodeUnsigned(buf,parent.id,false);
 8570        lib_fast::SetPmapBit(pmap,0);
 8571    }
 8572    tid_SetAssigned(state);
 8573    state.tid = parent.id;
 8574    // Value82 scaled delta mandatory
 8575    if (!Value82_AssignedQ(state)) {
 8576        Value82_SetAssigned(state);
 8577        state.Value82 = algo::Decimal(0,0);
 8578    }
 8579    lib_fast::EncodeDeltaScaled(buf,state.Value82,parent.Value82,false);
 8580    state.Value82 = parent.Value82;
 8581    lib_fast::InsertPmap(buf,index,pmap);
 8582}
 8583
 8584// --- fasttest.SclDeltaImpl..FastDecode
 8585bool fasttest::SclDeltaImpl_FastDecode(algo::memptr& from, u64 pmap, FastState& state, fasttest::SclDeltaImpl& parent) {
 8586    bool ok = true;
 8587    // Value82 scaled delta mandatory
 8588    if (ok) {
 8589        if (!Value82_AssignedQ(state)) {
 8590            Value82_SetAssigned(state);
 8591            state.Value82 = algo::Decimal(0,0);
 8592        }
 8593        ok = lib_fast::DecodeDeltaScaled(from,state.Value82,parent.Value82,false);
 8594        if (!ok) {
 8595            state.error << "fasttest.SclDeltaImpl.Value82: bad Scaled delta" << eol;
 8596        }
 8597        state.Value82 = parent.Value82;
 8598    }
 8599    (void)pmap;//only to avoid -Wunused-parameter
 8600    return ok;
 8601}
 8602
 8603// --- fasttest.SclDeltaImpl..FixEncode
 8604void fasttest::SclDeltaImpl_FixEncode(cstring& buf, fasttest::SclDeltaImpl& parent, char soh) {
 8605    buf << "1=" << parent.Value82 << soh;
 8606}
 8607
 8608// --- fasttest.SclDeltaNull.base.CopyOut
 8609// Copy fields out of row
 8610void fasttest::parent_CopyOut(fasttest::SclDeltaNull &row, fasttest::TemplateHeader &out) {
 8611    // length: field value is computed
 8612    // id: field value is computed
 8613    (void)row;//only to avoid -Wunused-parameter
 8614    (void)out;//only to avoid -Wunused-parameter
 8615}
 8616
 8617// --- fasttest.SclDeltaNull.Value84.ReadStrptrMaybe
 8618inline static bool fasttest::Value84_ReadStrptrMaybe(fasttest::SclDeltaNull &parent, algo::strptr in_str) {
 8619    bool retval = true;
 8620    algo::Decimal Value84_tmp;
 8621    retval = algo::Decimal_ReadStrptrMaybe(Value84_tmp, in_str);
 8622    if (retval) {
 8623        Value84_Set(parent, Value84_tmp);
 8624    }
 8625    return retval;
 8626}
 8627
 8628// --- fasttest.SclDeltaNull.pmask_bitcurs.Next
 8629// proceed to next item
 8630void fasttest::SclDeltaNull_pmask_bitcurs_Next(SclDeltaNull_pmask_bitcurs &curs) {
 8631    ++curs.bit;
 8632    int index = curs.bit / 32;
 8633    int offset = curs.bit % 32;
 8634    for (; index < curs.n_elems; ++index, offset = 0) {
 8635        u64 rest = curs.elems[index] >> offset;
 8636        if (rest) {
 8637            offset += algo::u64_BitScanForward(rest);
 8638            break;
 8639        }
 8640    }
 8641    curs.bit = index * 32 + offset;
 8642}
 8643
 8644// --- fasttest.SclDeltaNull..ReadFieldMaybe
 8645bool fasttest::SclDeltaNull_ReadFieldMaybe(fasttest::SclDeltaNull& parent, algo::strptr field, algo::strptr strval) {
 8646    bool retval = true;
 8647    fasttest::FieldId field_id;
 8648    (void)value_SetStrptrMaybe(field_id,field);
 8649    switch(field_id) {
 8650        case fasttest_FieldId_base: {
 8651            retval = false;
 8652            break;
 8653        }
 8654        case fasttest_FieldId_length: {
 8655            retval = false;
 8656            break;
 8657        }
 8658        case fasttest_FieldId_id: {
 8659            retval = false;
 8660            break;
 8661        }
 8662        case fasttest_FieldId_pmask: {
 8663            retval = false;
 8664            break;
 8665        }
 8666        case fasttest_FieldId_Value84: {
 8667            retval = Value84_ReadStrptrMaybe(parent, strval);
 8668            if (retval) {
 8669                pmask_qSetBit(parent, 0);
 8670            }
 8671            break;
 8672        }
 8673        default: break;
 8674    }
 8675    if (!retval) {
 8676        algo_lib::AppendErrtext("attr",field);
 8677    }
 8678    return retval;
 8679}
 8680
 8681// --- fasttest.SclDeltaNull..ReadStrptrMaybe
 8682// Read fields of fasttest::SclDeltaNull from an ascii string.
 8683// The format of the string is an ssim Tuple
 8684bool fasttest::SclDeltaNull_ReadStrptrMaybe(fasttest::SclDeltaNull &parent, algo::strptr in_str) {
 8685    bool retval = true;
 8686    retval = algo::StripTypeTag(in_str, "fasttest.SclDeltaNull");
 8687    ind_beg(algo::Attr_curs, attr, in_str) {
 8688        retval = retval && SclDeltaNull_ReadFieldMaybe(parent, attr.name, attr.value);
 8689    }ind_end;
 8690    return retval;
 8691}
 8692
 8693// --- fasttest.SclDeltaNull..Print
 8694// print string representation of ROW to string STR
 8695// cfmt:fasttest.SclDeltaNull.String  printfmt:Tuple
 8696void fasttest::SclDeltaNull_Print(fasttest::SclDeltaNull& row, algo::cstring& str) {
 8697    algo::tempstr temp;
 8698    str << "fasttest.SclDeltaNull";
 8699
 8700    if (Value84_PresentQ(row)) {
 8701        algo::Decimal_Print(row.Value84, temp);
 8702        PrintAttrSpaceReset(str,"Value84", temp);
 8703    }
 8704}
 8705
 8706// --- fasttest.SclDeltaNull..FastEncode
 8707void fasttest::SclDeltaNull_FastEncode(algo::ByteAry& buf, FastState& state, fasttest::SclDeltaNull& parent) {
 8708    int index = ary_N(buf);
 8709    u64 pmap(0);
 8710    if (!tid_AssignedQ(state) || parent.id != state.tid) {
 8711        lib_fast::EncodeUnsigned(buf,parent.id,false);
 8712        lib_fast::SetPmapBit(pmap,0);
 8713    }
 8714    tid_SetAssigned(state);
 8715    state.tid = parent.id;
 8716    // Value84 scaled delta optional
 8717    if (!Value84_AssignedQ(state)) {
 8718        Value84_SetAssigned(state);
 8719        present_qSetBitVal(state,Value84_Present_GetBit(state),Value84_PresentQ(parent));
 8720        state.Value84 = algo::Decimal(0,0);
 8721    }
 8722    if (Value84_PresentQ(parent)) {
 8723        if (!Value84_PresentQ(state)) {
 8724            state.Value84 = algo::Decimal(0,0);
 8725        }
 8726        lib_fast::EncodeDeltaScaled(buf,state.Value84,parent.Value84,true);
 8727    } else {
 8728        lib_fast::EncodeNull(buf);
 8729    }
 8730    state.Value84 = parent.Value84;
 8731    present_qSetBitVal(state,Value84_Present_GetBit(state),Value84_PresentQ(parent));
 8732    lib_fast::InsertPmap(buf,index,pmap);
 8733}
 8734
 8735// --- fasttest.SclDeltaNull..FastDecode
 8736bool fasttest::SclDeltaNull_FastDecode(algo::memptr& from, u64 pmap, FastState& state, fasttest::SclDeltaNull& parent) {
 8737    bool ok = true;
 8738    // Value84 scaled delta optional
 8739    if (ok) {
 8740        if (!Value84_AssignedQ(state)) {
 8741            Value84_SetAssigned(state);
 8742            bool prs(true);
 8743            present_qSetBitVal(state,Value84_Present_GetBit(state),prs);
 8744            state.Value84 = algo::Decimal(0,0);
 8745        }
 8746        bool prs = !lib_fast::DecodeNull(from);
 8747        if (prs) {
 8748            if (!Value84_PresentQ(state)) {
 8749                state.Value84 = algo::Decimal(0,0);
 8750            }
 8751            ok = lib_fast::DecodeDeltaScaled(from,state.Value84,parent.Value84,true);
 8752            if (!ok) {
 8753                state.error << "fasttest.SclDeltaNull.Value84: bad Scaled delta" << eol;
 8754            }
 8755            state.Value84 = parent.Value84;
 8756        }
 8757        pmask_qSetBitVal(parent,Value84_Present_GetBit(parent),prs);
 8758        present_qSetBitVal(state,Value84_Present_GetBit(state),prs);
 8759    }
 8760    (void)pmap;//only to avoid -Wunused-parameter
 8761    return ok;
 8762}
 8763
 8764// --- fasttest.SclDeltaNull..FixEncode
 8765void fasttest::SclDeltaNull_FixEncode(cstring& buf, fasttest::SclDeltaNull& parent, char soh) {
 8766    if (Value84_PresentQ(parent)) {
 8767        buf << "1=" << parent.Value84 << soh;
 8768    }
 8769}
 8770
 8771// --- fasttest.SclDeltaOpt.base.CopyOut
 8772// Copy fields out of row
 8773void fasttest::parent_CopyOut(fasttest::SclDeltaOpt &row, fasttest::TemplateHeader &out) {
 8774    // length: field value is computed
 8775    // id: field value is computed
 8776    (void)row;//only to avoid -Wunused-parameter
 8777    (void)out;//only to avoid -Wunused-parameter
 8778}
 8779
 8780// --- fasttest.SclDeltaOpt.Value83.ReadStrptrMaybe
 8781inline static bool fasttest::Value83_ReadStrptrMaybe(fasttest::SclDeltaOpt &parent, algo::strptr in_str) {
 8782    bool retval = true;
 8783    algo::Decimal Value83_tmp;
 8784    retval = algo::Decimal_ReadStrptrMaybe(Value83_tmp, in_str);
 8785    if (retval) {
 8786        Value83_Set(parent, Value83_tmp);
 8787    }
 8788    return retval;
 8789}
 8790
 8791// --- fasttest.SclDeltaOpt.pmask_bitcurs.Next
 8792// proceed to next item
 8793void fasttest::SclDeltaOpt_pmask_bitcurs_Next(SclDeltaOpt_pmask_bitcurs &curs) {
 8794    ++curs.bit;
 8795    int index = curs.bit / 32;
 8796    int offset = curs.bit % 32;
 8797    for (; index < curs.n_elems; ++index, offset = 0) {
 8798        u64 rest = curs.elems[index] >> offset;
 8799        if (rest) {
 8800            offset += algo::u64_BitScanForward(rest);
 8801            break;
 8802        }
 8803    }
 8804    curs.bit = index * 32 + offset;
 8805}
 8806
 8807// --- fasttest.SclDeltaOpt..ReadFieldMaybe
 8808bool fasttest::SclDeltaOpt_ReadFieldMaybe(fasttest::SclDeltaOpt& parent, algo::strptr field, algo::strptr strval) {
 8809    bool retval = true;
 8810    fasttest::FieldId field_id;
 8811    (void)value_SetStrptrMaybe(field_id,field);
 8812    switch(field_id) {
 8813        case fasttest_FieldId_base: {
 8814            retval = false;
 8815            break;
 8816        }
 8817        case fasttest_FieldId_length: {
 8818            retval = false;
 8819            break;
 8820        }
 8821        case fasttest_FieldId_id: {
 8822            retval = false;
 8823            break;
 8824        }
 8825        case fasttest_FieldId_pmask: {
 8826            retval = false;
 8827            break;
 8828        }
 8829        case fasttest_FieldId_Value83: {
 8830            retval = Value83_ReadStrptrMaybe(parent, strval);
 8831            if (retval) {
 8832                pmask_qSetBit(parent, 0);
 8833            }
 8834            break;
 8835        }
 8836        default: break;
 8837    }
 8838    if (!retval) {
 8839        algo_lib::AppendErrtext("attr",field);
 8840    }
 8841    return retval;
 8842}
 8843
 8844// --- fasttest.SclDeltaOpt..ReadStrptrMaybe
 8845// Read fields of fasttest::SclDeltaOpt from an ascii string.
 8846// The format of the string is an ssim Tuple
 8847bool fasttest::SclDeltaOpt_ReadStrptrMaybe(fasttest::SclDeltaOpt &parent, algo::strptr in_str) {
 8848    bool retval = true;
 8849    retval = algo::StripTypeTag(in_str, "fasttest.SclDeltaOpt");
 8850    ind_beg(algo::Attr_curs, attr, in_str) {
 8851        retval = retval && SclDeltaOpt_ReadFieldMaybe(parent, attr.name, attr.value);
 8852    }ind_end;
 8853    return retval;
 8854}
 8855
 8856// --- fasttest.SclDeltaOpt..Print
 8857// print string representation of ROW to string STR
 8858// cfmt:fasttest.SclDeltaOpt.String  printfmt:Tuple
 8859void fasttest::SclDeltaOpt_Print(fasttest::SclDeltaOpt& row, algo::cstring& str) {
 8860    algo::tempstr temp;
 8861    str << "fasttest.SclDeltaOpt";
 8862
 8863    if (Value83_PresentQ(row)) {
 8864        algo::Decimal_Print(row.Value83, temp);
 8865        PrintAttrSpaceReset(str,"Value83", temp);
 8866    }
 8867}
 8868
 8869// --- fasttest.SclDeltaOpt..FastEncode
 8870void fasttest::SclDeltaOpt_FastEncode(algo::ByteAry& buf, FastState& state, fasttest::SclDeltaOpt& parent) {
 8871    int index = ary_N(buf);
 8872    u64 pmap(0);
 8873    if (!tid_AssignedQ(state) || parent.id != state.tid) {
 8874        lib_fast::EncodeUnsigned(buf,parent.id,false);
 8875        lib_fast::SetPmapBit(pmap,0);
 8876    }
 8877    tid_SetAssigned(state);
 8878    state.tid = parent.id;
 8879    // Value83 scaled delta optional
 8880    if (!Value83_AssignedQ(state)) {
 8881        Value83_SetAssigned(state);
 8882        present_qSetBitVal(state,Value83_Present_GetBit(state),Value83_PresentQ(parent));
 8883        state.Value83 = algo::Decimal(1,-83);
 8884    }
 8885    if (Value83_PresentQ(parent)) {
 8886        if (!Value83_PresentQ(state)) {
 8887            state.Value83 = algo::Decimal(1,-83);
 8888        }
 8889        lib_fast::EncodeDeltaScaled(buf,state.Value83,parent.Value83,true);
 8890    } else {
 8891        lib_fast::EncodeNull(buf);
 8892    }
 8893    state.Value83 = parent.Value83;
 8894    present_qSetBitVal(state,Value83_Present_GetBit(state),Value83_PresentQ(parent));
 8895    lib_fast::InsertPmap(buf,index,pmap);
 8896}
 8897
 8898// --- fasttest.SclDeltaOpt..FastDecode
 8899bool fasttest::SclDeltaOpt_FastDecode(algo::memptr& from, u64 pmap, FastState& state, fasttest::SclDeltaOpt& parent) {
 8900    bool ok = true;
 8901    // Value83 scaled delta optional
 8902    if (ok) {
 8903        if (!Value83_AssignedQ(state)) {
 8904            Value83_SetAssigned(state);
 8905            bool prs(true);
 8906            present_qSetBitVal(state,Value83_Present_GetBit(state),prs);
 8907            state.Value83 = algo::Decimal(1,-83);
 8908        }
 8909        bool prs = !lib_fast::DecodeNull(from);
 8910        if (prs) {
 8911            if (!Value83_PresentQ(state)) {
 8912                state.Value83 = algo::Decimal(1,-83);
 8913            }
 8914            ok = lib_fast::DecodeDeltaScaled(from,state.Value83,parent.Value83,true);
 8915            if (!ok) {
 8916                state.error << "fasttest.SclDeltaOpt.Value83: bad Scaled delta" << eol;
 8917            }
 8918            state.Value83 = parent.Value83;
 8919        }
 8920        pmask_qSetBitVal(parent,Value83_Present_GetBit(parent),prs);
 8921        present_qSetBitVal(state,Value83_Present_GetBit(state),prs);
 8922    }
 8923    (void)pmap;//only to avoid -Wunused-parameter
 8924    return ok;
 8925}
 8926
 8927// --- fasttest.SclDeltaOpt..FixEncode
 8928void fasttest::SclDeltaOpt_FixEncode(cstring& buf, fasttest::SclDeltaOpt& parent, char soh) {
 8929    if (Value83_PresentQ(parent)) {
 8930        buf << "1=" << parent.Value83 << soh;
 8931    }
 8932}
 8933
 8934// --- fasttest.SclDflt.base.CopyOut
 8935// Copy fields out of row
 8936void fasttest::parent_CopyOut(fasttest::SclDflt &row, fasttest::TemplateHeader &out) {
 8937    // length: field value is computed
 8938    // id: field value is computed
 8939    (void)row;//only to avoid -Wunused-parameter
 8940    (void)out;//only to avoid -Wunused-parameter
 8941}
 8942
 8943// --- fasttest.SclDflt..ReadFieldMaybe
 8944bool fasttest::SclDflt_ReadFieldMaybe(fasttest::SclDflt& parent, algo::strptr field, algo::strptr strval) {
 8945    bool retval = true;
 8946    fasttest::FieldId field_id;
 8947    (void)value_SetStrptrMaybe(field_id,field);
 8948    switch(field_id) {
 8949        case fasttest_FieldId_base: {
 8950            retval = false;
 8951            break;
 8952        }
 8953        case fasttest_FieldId_length: {
 8954            retval = false;
 8955            break;
 8956        }
 8957        case fasttest_FieldId_id: {
 8958            retval = false;
 8959            break;
 8960        }
 8961        case fasttest_FieldId_Value: {
 8962            retval = algo::Decimal_ReadStrptrMaybe(parent.Value, strval);
 8963            break;
 8964        }
 8965        default: break;
 8966    }
 8967    if (!retval) {
 8968        algo_lib::AppendErrtext("attr",field);
 8969    }
 8970    return retval;
 8971}
 8972
 8973// --- fasttest.SclDflt..ReadStrptrMaybe
 8974// Read fields of fasttest::SclDflt from an ascii string.
 8975// The format of the string is an ssim Tuple
 8976bool fasttest::SclDflt_ReadStrptrMaybe(fasttest::SclDflt &parent, algo::strptr in_str) {
 8977    bool retval = true;
 8978    retval = algo::StripTypeTag(in_str, "fasttest.SclDflt");
 8979    ind_beg(algo::Attr_curs, attr, in_str) {
 8980        retval = retval && SclDflt_ReadFieldMaybe(parent, attr.name, attr.value);
 8981    }ind_end;
 8982    return retval;
 8983}
 8984
 8985// --- fasttest.SclDflt..Print
 8986// print string representation of ROW to string STR
 8987// cfmt:fasttest.SclDflt.String  printfmt:Tuple
 8988void fasttest::SclDflt_Print(fasttest::SclDflt& row, algo::cstring& str) {
 8989    algo::tempstr temp;
 8990    str << "fasttest.SclDflt";
 8991
 8992    algo::Decimal_Print(row.Value, temp);
 8993    PrintAttrSpaceReset(str,"Value", temp);
 8994}
 8995
 8996// --- fasttest.SclDflt..FastEncode
 8997void fasttest::SclDflt_FastEncode(algo::ByteAry& buf, FastState& state, fasttest::SclDflt& parent) {
 8998    int index = ary_N(buf);
 8999    u64 pmap(0);
 9000    if (!tid_AssignedQ(state) || parent.id != state.tid) {
 9001        lib_fast::EncodeUnsigned(buf,parent.id,false);
 9002        lib_fast::SetPmapBit(pmap,0);
 9003    }
 9004    tid_SetAssigned(state);
 9005    state.tid = parent.id;
 9006    // Value scaled default mandatory
 9007    if (parent.Value != algo::Decimal(-2,-45)) {
 9008        lib_fast::EncodeScaled(buf,parent.Value,false);
 9009        lib_fast::SetPmapBit(pmap,1);
 9010    }
 9011    lib_fast::InsertPmap(buf,index,pmap);
 9012}
 9013
 9014// --- fasttest.SclDflt..FastDecode
 9015bool fasttest::SclDflt_FastDecode(algo::memptr& from, u64 pmap, FastState& state, fasttest::SclDflt& parent) {
 9016    bool ok = true;
 9017    // Value scaled default mandatory
 9018    if (ok) {
 9019        bool prs = lib_fast::GetPmapBit(pmap,1);
 9020        if (prs) {
 9021            ok = lib_fast::DecodeScaled(from,parent.Value,false);
 9022            if (!ok) {
 9023                state.error << "fasttest.SclDflt.Value: bad Scaled" << eol;
 9024            }
 9025        } else {
 9026            parent.Value = algo::Decimal(-2,-45);
 9027        }
 9028    }
 9029    return ok;
 9030}
 9031
 9032// --- fasttest.SclDflt..FixEncode
 9033void fasttest::SclDflt_FixEncode(cstring& buf, fasttest::SclDflt& parent, char soh) {
 9034    buf << "1=" << parent.Value << soh;
 9035}
 9036
 9037// --- fasttest.SclDfltNull.base.CopyOut
 9038// Copy fields out of row
 9039void fasttest::parent_CopyOut(fasttest::SclDfltNull &row, fasttest::TemplateHeader &out) {
 9040    // length: field value is computed
 9041    // id: field value is computed
 9042    (void)row;//only to avoid -Wunused-parameter
 9043    (void)out;//only to avoid -Wunused-parameter
 9044}
 9045
 9046// --- fasttest.SclDfltNull.Value.ReadStrptrMaybe
 9047inline static bool fasttest::Value_ReadStrptrMaybe(fasttest::SclDfltNull &parent, algo::strptr in_str) {
 9048    bool retval = true;
 9049    algo::Decimal Value_tmp;
 9050    retval = algo::Decimal_ReadStrptrMaybe(Value_tmp, in_str);
 9051    if (retval) {
 9052        Value_Set(parent, Value_tmp);
 9053    }
 9054    return retval;
 9055}
 9056
 9057// --- fasttest.SclDfltNull.pmask_bitcurs.Next
 9058// proceed to next item
 9059void fasttest::SclDfltNull_pmask_bitcurs_Next(SclDfltNull_pmask_bitcurs &curs) {
 9060    ++curs.bit;
 9061    int index = curs.bit / 32;
 9062    int offset = curs.bit % 32;
 9063    for (; index < curs.n_elems; ++index, offset = 0) {
 9064        u64 rest = curs.elems[index] >> offset;
 9065        if (rest) {
 9066            offset += algo::u64_BitScanForward(rest);
 9067            break;
 9068        }
 9069    }
 9070    curs.bit = index * 32 + offset;
 9071}
 9072
 9073// --- fasttest.SclDfltNull..ReadFieldMaybe
 9074bool fasttest::SclDfltNull_ReadFieldMaybe(fasttest::SclDfltNull& parent, algo::strptr field, algo::strptr strval) {
 9075    bool retval = true;
 9076    fasttest::FieldId field_id;
 9077    (void)value_SetStrptrMaybe(field_id,field);
 9078    switch(field_id) {
 9079        case fasttest_FieldId_base: {
 9080            retval = false;
 9081            break;
 9082        }
 9083        case fasttest_FieldId_length: {
 9084            retval = false;
 9085            break;
 9086        }
 9087        case fasttest_FieldId_id: {
 9088            retval = false;
 9089            break;
 9090        }
 9091        case fasttest_FieldId_pmask: {
 9092            retval = false;
 9093            break;
 9094        }
 9095        case fasttest_FieldId_Value: {
 9096            retval = Value_ReadStrptrMaybe(parent, strval);
 9097            if (retval) {
 9098                pmask_qSetBit(parent, 0);
 9099            }
 9100            break;
 9101        }
 9102        default: break;
 9103    }
 9104    if (!retval) {
 9105        algo_lib::AppendErrtext("attr",field);
 9106    }
 9107    return retval;
 9108}
 9109
 9110// --- fasttest.SclDfltNull..ReadStrptrMaybe
 9111// Read fields of fasttest::SclDfltNull from an ascii string.
 9112// The format of the string is an ssim Tuple
 9113bool fasttest::SclDfltNull_ReadStrptrMaybe(fasttest::SclDfltNull &parent, algo::strptr in_str) {
 9114    bool retval = true;
 9115    retval = algo::StripTypeTag(in_str, "fasttest.SclDfltNull");
 9116    ind_beg(algo::Attr_curs, attr, in_str) {
 9117        retval = retval && SclDfltNull_ReadFieldMaybe(parent, attr.name, attr.value);
 9118    }ind_end;
 9119    return retval;
 9120}
 9121
 9122// --- fasttest.SclDfltNull..Print
 9123// print string representation of ROW to string STR
 9124// cfmt:fasttest.SclDfltNull.String  printfmt:Tuple
 9125void fasttest::SclDfltNull_Print(fasttest::SclDfltNull& row, algo::cstring& str) {
 9126    algo::tempstr temp;
 9127    str << "fasttest.SclDfltNull";
 9128
 9129    if (Value_PresentQ(row)) {
 9130        algo::Decimal_Print(row.Value, temp);
 9131        PrintAttrSpaceReset(str,"Value", temp);
 9132    }
 9133}
 9134
 9135// --- fasttest.SclDfltNull..FastEncode
 9136void fasttest::SclDfltNull_FastEncode(algo::ByteAry& buf, FastState& state, fasttest::SclDfltNull& parent) {
 9137    int index = ary_N(buf);
 9138    u64 pmap(0);
 9139    if (!tid_AssignedQ(state) || parent.id != state.tid) {
 9140        lib_fast::EncodeUnsigned(buf,parent.id,false);
 9141        lib_fast::SetPmapBit(pmap,0);
 9142    }
 9143    tid_SetAssigned(state);
 9144    state.tid = parent.id;
 9145    // Value scaled default optional
 9146    if (Value_PresentQ(parent)) {
 9147        if (parent.Value != algo::Decimal(0,0)) {
 9148            lib_fast::EncodeScaled(buf,parent.Value,true);
 9149            lib_fast::SetPmapBit(pmap,1);
 9150        }
 9151    } else {
 9152        lib_fast::EncodeNull(buf);
 9153        lib_fast::SetPmapBit(pmap,1);
 9154    }
 9155    lib_fast::InsertPmap(buf,index,pmap);
 9156}
 9157
 9158// --- fasttest.SclDfltNull..FastDecode
 9159bool fasttest::SclDfltNull_FastDecode(algo::memptr& from, u64 pmap, FastState& state, fasttest::SclDfltNull& parent) {
 9160    bool ok = true;
 9161    // Value scaled default optional
 9162    if (ok) {
 9163        bool prs = lib_fast::GetPmapBit(pmap,1);
 9164        if (prs) {
 9165            prs = !lib_fast::DecodeNull(from);
 9166            if (prs) {
 9167                ok = lib_fast::DecodeScaled(from,parent.Value,true);
 9168                if (!ok) {
 9169                    state.error << "fasttest.SclDfltNull.Value: bad Scaled" << eol;
 9170                }
 9171            }
 9172        } else {
 9173            parent.Value = algo::Decimal(0,0);
 9174            prs = true;
 9175        }
 9176        pmask_qSetBitVal(parent,Value_Present_GetBit(parent),prs);
 9177    }
 9178    return ok;
 9179}
 9180
 9181// --- fasttest.SclDfltNull..FixEncode
 9182void fasttest::SclDfltNull_FixEncode(cstring& buf, fasttest::SclDfltNull& parent, char soh) {
 9183    if (Value_PresentQ(parent)) {
 9184        buf << "1=" << parent.Value << soh;
 9185    }
 9186}
 9187
 9188// --- fasttest.SclDfltOpt.base.CopyOut
 9189// Copy fields out of row
 9190void fasttest::parent_CopyOut(fasttest::SclDfltOpt &row, fasttest::TemplateHeader &out) {
 9191    // length: field value is computed
 9192    // id: field value is computed
 9193    (void)row;//only to avoid -Wunused-parameter
 9194    (void)out;//only to avoid -Wunused-parameter
 9195}
 9196
 9197// --- fasttest.SclDfltOpt.Value.ReadStrptrMaybe
 9198inline static bool fasttest::Value_ReadStrptrMaybe(fasttest::SclDfltOpt &parent, algo::strptr in_str) {
 9199    bool retval = true;
 9200    algo::Decimal Value_tmp;
 9201    retval = algo::Decimal_ReadStrptrMaybe(Value_tmp, in_str);
 9202    if (retval) {
 9203        Value_Set(parent, Value_tmp);
 9204    }
 9205    return retval;
 9206}
 9207
 9208// --- fasttest.SclDfltOpt.pmask_bitcurs.Next
 9209// proceed to next item
 9210void fasttest::SclDfltOpt_pmask_bitcurs_Next(SclDfltOpt_pmask_bitcurs &curs) {
 9211    ++curs.bit;
 9212    int index = curs.bit / 32;
 9213    int offset = curs.bit % 32;
 9214    for (; index < curs.n_elems; ++index, offset = 0) {
 9215        u64 rest = curs.elems[index] >> offset;
 9216        if (rest) {
 9217            offset += algo::u64_BitScanForward(rest);
 9218            break;
 9219        }
 9220    }
 9221    curs.bit = index * 32 + offset;
 9222}
 9223
 9224// --- fasttest.SclDfltOpt..ReadFieldMaybe
 9225bool fasttest::SclDfltOpt_ReadFieldMaybe(fasttest::SclDfltOpt& parent, algo::strptr field, algo::strptr strval) {
 9226    bool retval = true;
 9227    fasttest::FieldId field_id;
 9228    (void)value_SetStrptrMaybe(field_id,field);
 9229    switch(field_id) {
 9230        case fasttest_FieldId_base: {
 9231            retval = false;
 9232            break;
 9233        }
 9234        case fasttest_FieldId_length: {
 9235            retval = false;
 9236            break;
 9237        }
 9238        case fasttest_FieldId_id: {
 9239            retval = false;
 9240            break;
 9241        }
 9242        case fasttest_FieldId_pmask: {
 9243            retval = false;
 9244            break;
 9245        }
 9246        case fasttest_FieldId_Value: {
 9247            retval = Value_ReadStrptrMaybe(parent, strval);
 9248            if (retval) {
 9249                pmask_qSetBit(parent, 0);
 9250            }
 9251            break;
 9252        }
 9253        default: break;
 9254    }
 9255    if (!retval) {
 9256        algo_lib::AppendErrtext("attr",field);
 9257    }
 9258    return retval;
 9259}
 9260
 9261// --- fasttest.SclDfltOpt..ReadStrptrMaybe
 9262// Read fields of fasttest::SclDfltOpt from an ascii string.
 9263// The format of the string is an ssim Tuple
 9264bool fasttest::SclDfltOpt_ReadStrptrMaybe(fasttest::SclDfltOpt &parent, algo::strptr in_str) {
 9265    bool retval = true;
 9266    retval = algo::StripTypeTag(in_str, "fasttest.SclDfltOpt");
 9267    ind_beg(algo::Attr_curs, attr, in_str) {
 9268        retval = retval && SclDfltOpt_ReadFieldMaybe(parent, attr.name, attr.value);
 9269    }ind_end;
 9270    return retval;
 9271}
 9272
 9273// --- fasttest.SclDfltOpt..Print
 9274// print string representation of ROW to string STR
 9275// cfmt:fasttest.SclDfltOpt.String  printfmt:Tuple
 9276void fasttest::SclDfltOpt_Print(fasttest::SclDfltOpt& row, algo::cstring& str) {
 9277    algo::tempstr temp;
 9278    str << "fasttest.SclDfltOpt";
 9279
 9280    if (Value_PresentQ(row)) {
 9281        algo::Decimal_Print(row.Value, temp);
 9282        PrintAttrSpaceReset(str,"Value", temp);
 9283    }
 9284}
 9285
 9286// --- fasttest.SclDfltOpt..FastEncode
 9287void fasttest::SclDfltOpt_FastEncode(algo::ByteAry& buf, FastState& state, fasttest::SclDfltOpt& parent) {
 9288    int index = ary_N(buf);
 9289    u64 pmap(0);
 9290    if (!tid_AssignedQ(state) || parent.id != state.tid) {
 9291        lib_fast::EncodeUnsigned(buf,parent.id,false);
 9292        lib_fast::SetPmapBit(pmap,0);
 9293    }
 9294    tid_SetAssigned(state);
 9295    state.tid = parent.id;
 9296    // Value scaled default optional
 9297    if (Value_PresentQ(parent)) {
 9298        if (parent.Value != algo::Decimal(1,-46)) {
 9299            lib_fast::EncodeScaled(buf,parent.Value,true);
 9300            lib_fast::SetPmapBit(pmap,1);
 9301        }
 9302    } else {
 9303        lib_fast::EncodeNull(buf);
 9304        lib_fast::SetPmapBit(pmap,1);
 9305    }
 9306    lib_fast::InsertPmap(buf,index,pmap);
 9307}
 9308
 9309// --- fasttest.SclDfltOpt..FastDecode
 9310bool fasttest::SclDfltOpt_FastDecode(algo::memptr& from, u64 pmap, FastState& state, fasttest::SclDfltOpt& parent) {
 9311    bool ok = true;
 9312    // Value scaled default optional
 9313    if (ok) {
 9314        bool prs = lib_fast::GetPmapBit(pmap,1);
 9315        if (prs) {
 9316            prs = !lib_fast::DecodeNull(from);
 9317            if (prs) {
 9318                ok = lib_fast::DecodeScaled(from,parent.Value,true);
 9319                if (!ok) {
 9320                    state.error << "fasttest.SclDfltOpt.Value: bad Scaled" << eol;
 9321                }
 9322            }
 9323        } else {
 9324            parent.Value = algo::Decimal(1,-46);
 9325            prs = true;
 9326        }
 9327        pmask_qSetBitVal(parent,Value_Present_GetBit(parent),prs);
 9328    }
 9329    return ok;
 9330}
 9331
 9332// --- fasttest.SclDfltOpt..FixEncode
 9333void fasttest::SclDfltOpt_FixEncode(cstring& buf, fasttest::SclDfltOpt& parent, char soh) {
 9334    if (Value_PresentQ(parent)) {
 9335        buf << "1=" << parent.Value << soh;
 9336    }
 9337}
 9338
 9339// --- fasttest.SclNone.base.CopyOut
 9340// Copy fields out of row
 9341void fasttest::parent_CopyOut(fasttest::SclNone &row, fasttest::TemplateHeader &out) {
 9342    // length: field value is computed
 9343    // id: field value is computed
 9344    (void)row;//only to avoid -Wunused-parameter
 9345    (void)out;//only to avoid -Wunused-parameter
 9346}
 9347
 9348// --- fasttest.SclNone..ReadFieldMaybe
 9349bool fasttest::SclNone_ReadFieldMaybe(fasttest::SclNone& parent, algo::strptr field, algo::strptr strval) {
 9350    bool retval = true;
 9351    fasttest::FieldId field_id;
 9352    (void)value_SetStrptrMaybe(field_id,field);
 9353    switch(field_id) {
 9354        case fasttest_FieldId_base: {
 9355            retval = false;
 9356            break;
 9357        }
 9358        case fasttest_FieldId_length: {
 9359            retval = false;
 9360            break;
 9361        }
 9362        case fasttest_FieldId_id: {
 9363            retval = false;
 9364            break;
 9365        }
 9366        case fasttest_FieldId_Value: {
 9367            retval = algo::Decimal_ReadStrptrMaybe(parent.Value, strval);
 9368            break;
 9369        }
 9370        default: break;
 9371    }
 9372    if (!retval) {
 9373        algo_lib::AppendErrtext("attr",field);
 9374    }
 9375    return retval;
 9376}
 9377
 9378// --- fasttest.SclNone..ReadStrptrMaybe
 9379// Read fields of fasttest::SclNone from an ascii string.
 9380// The format of the string is an ssim Tuple
 9381bool fasttest::SclNone_ReadStrptrMaybe(fasttest::SclNone &parent, algo::strptr in_str) {
 9382    bool retval = true;
 9383    retval = algo::StripTypeTag(in_str, "fasttest.SclNone");
 9384    ind_beg(algo::Attr_curs, attr, in_str) {
 9385        retval = retval && SclNone_ReadFieldMaybe(parent, attr.name, attr.value);
 9386    }ind_end;
 9387    return retval;
 9388}
 9389
 9390// --- fasttest.SclNone..Print
 9391// print string representation of ROW to string STR
 9392// cfmt:fasttest.SclNone.String  printfmt:Tuple
 9393void fasttest::SclNone_Print(fasttest::SclNone& row, algo::cstring& str) {
 9394    algo::tempstr temp;
 9395    str << "fasttest.SclNone";
 9396
 9397    algo::Decimal_Print(row.Value, temp);
 9398    PrintAttrSpaceReset(str,"Value", temp);
 9399}
 9400
 9401// --- fasttest.SclNone..FastEncode
 9402void fasttest::SclNone_FastEncode(algo::ByteAry& buf, FastState& state, fasttest::SclNone& parent) {
 9403    int index = ary_N(buf);
 9404    u64 pmap(0);
 9405    if (!tid_AssignedQ(state) || parent.id != state.tid) {
 9406        lib_fast::EncodeUnsigned(buf,parent.id,false);
 9407        lib_fast::SetPmapBit(pmap,0);
 9408    }
 9409    tid_SetAssigned(state);
 9410    state.tid = parent.id;
 9411    // Value scaled none mandatory
 9412    lib_fast::EncodeScaled(buf,parent.Value,false);
 9413    lib_fast::InsertPmap(buf,index,pmap);
 9414}
 9415
 9416// --- fasttest.SclNone..FastDecode
 9417bool fasttest::SclNone_FastDecode(algo::memptr& from, u64 pmap, FastState& state, fasttest::SclNone& parent) {
 9418    bool ok = true;
 9419    // Value scaled none mandatory
 9420    if (ok) {
 9421        ok = lib_fast::DecodeScaled(from,parent.Value,false);
 9422        if (!ok) {
 9423            state.error << "fasttest.SclNone.Value: bad Scaled" << eol;
 9424        }
 9425    }
 9426    (void)pmap;//only to avoid -Wunused-parameter
 9427    return ok;
 9428}
 9429
 9430// --- fasttest.SclNone..FixEncode
 9431void fasttest::SclNone_FixEncode(cstring& buf, fasttest::SclNone& parent, char soh) {
 9432    buf << "1=" << parent.Value << soh;
 9433}
 9434
 9435// --- fasttest.SclNoneOpt.base.CopyOut
 9436// Copy fields out of row
 9437void fasttest::parent_CopyOut(fasttest::SclNoneOpt &row, fasttest::TemplateHeader &out) {
 9438    // length: field value is computed
 9439    // id: field value is computed
 9440    (void)row;//only to avoid -Wunused-parameter
 9441    (void)out;//only to avoid -Wunused-parameter
 9442}
 9443
 9444// --- fasttest.SclNoneOpt.Value.ReadStrptrMaybe
 9445inline static bool fasttest::Value_ReadStrptrMaybe(fasttest::SclNoneOpt &parent, algo::strptr in_str) {
 9446    bool retval = true;
 9447    algo::Decimal Value_tmp;
 9448    retval = algo::Decimal_ReadStrptrMaybe(Value_tmp, in_str);
 9449    if (retval) {
 9450        Value_Set(parent, Value_tmp);
 9451    }
 9452    return retval;
 9453}
 9454
 9455// --- fasttest.SclNoneOpt.pmask_bitcurs.Next
 9456// proceed to next item
 9457void fasttest::SclNoneOpt_pmask_bitcurs_Next(SclNoneOpt_pmask_bitcurs &curs) {
 9458    ++curs.bit;
 9459    int index = curs.bit / 32;
 9460    int offset = curs.bit % 32;
 9461    for (; index < curs.n_elems; ++index, offset = 0) {
 9462        u64 rest = curs.elems[index] >> offset;
 9463        if (rest) {
 9464            offset += algo::u64_BitScanForward(rest);
 9465            break;
 9466        }
 9467    }
 9468    curs.bit = index * 32 + offset;
 9469}
 9470
 9471// --- fasttest.SclNoneOpt..ReadFieldMaybe
 9472bool fasttest::SclNoneOpt_ReadFieldMaybe(fasttest::SclNoneOpt& parent, algo::strptr field, algo::strptr strval) {
 9473    bool retval = true;
 9474    fasttest::FieldId field_id;
 9475    (void)value_SetStrptrMaybe(field_id,field);
 9476    switch(field_id) {
 9477        case fasttest_FieldId_base: {
 9478            retval = false;
 9479            break;
 9480        }
 9481        case fasttest_FieldId_length: {
 9482            retval = false;
 9483            break;
 9484        }
 9485        case fasttest_FieldId_id: {
 9486            retval = false;
 9487            break;
 9488        }
 9489        case fasttest_FieldId_pmask: {
 9490            retval = false;
 9491            break;
 9492        }
 9493        case fasttest_FieldId_Value: {
 9494            retval = Value_ReadStrptrMaybe(parent, strval);
 9495            if (retval) {
 9496                pmask_qSetBit(parent, 0);
 9497            }
 9498            break;
 9499        }
 9500        default: break;
 9501    }
 9502    if (!retval) {
 9503        algo_lib::AppendErrtext("attr",field);
 9504    }
 9505    return retval;
 9506}
 9507
 9508// --- fasttest.SclNoneOpt..ReadStrptrMaybe
 9509// Read fields of fasttest::SclNoneOpt from an ascii string.
 9510// The format of the string is an ssim Tuple
 9511bool fasttest::SclNoneOpt_ReadStrptrMaybe(fasttest::SclNoneOpt &parent, algo::strptr in_str) {
 9512    bool retval = true;
 9513    retval = algo::StripTypeTag(in_str, "fasttest.SclNoneOpt");
 9514    ind_beg(algo::Attr_curs, attr, in_str) {
 9515        retval = retval && SclNoneOpt_ReadFieldMaybe(parent, attr.name, attr.value);
 9516    }ind_end;
 9517    return retval;
 9518}
 9519
 9520// --- fasttest.SclNoneOpt..Print
 9521// print string representation of ROW to string STR
 9522// cfmt:fasttest.SclNoneOpt.String  printfmt:Tuple
 9523void fasttest::SclNoneOpt_Print(fasttest::SclNoneOpt& row, algo::cstring& str) {
 9524    algo::tempstr temp;
 9525    str << "fasttest.SclNoneOpt";
 9526
 9527    if (Value_PresentQ(row)) {
 9528        algo::Decimal_Print(row.Value, temp);
 9529        PrintAttrSpaceReset(str,"Value", temp);
 9530    }
 9531}
 9532
 9533// --- fasttest.SclNoneOpt..FastEncode
 9534void fasttest::SclNoneOpt_FastEncode(algo::ByteAry& buf, FastState& state, fasttest::SclNoneOpt& parent) {
 9535    int index = ary_N(buf);
 9536    u64 pmap(0);
 9537    if (!tid_AssignedQ(state) || parent.id != state.tid) {
 9538        lib_fast::EncodeUnsigned(buf,parent.id,false);
 9539        lib_fast::SetPmapBit(pmap,0);
 9540    }
 9541    tid_SetAssigned(state);
 9542    state.tid = parent.id;
 9543    // Value scaled none optional
 9544    if (Value_PresentQ(parent)) {
 9545        lib_fast::EncodeScaled(buf,parent.Value,true);
 9546    } else {
 9547        lib_fast::EncodeNull(buf);
 9548    }
 9549    lib_fast::InsertPmap(buf,index,pmap);
 9550}
 9551
 9552// --- fasttest.SclNoneOpt..FastDecode
 9553bool fasttest::SclNoneOpt_FastDecode(algo::memptr& from, u64 pmap, FastState& state, fasttest::SclNoneOpt& parent) {
 9554    bool ok = true;
 9555    // Value scaled none optional
 9556    if (ok) {
 9557        bool prs = !lib_fast::DecodeNull(from);
 9558        if (prs) {
 9559            ok = lib_fast::DecodeScaled(from,parent.Value,true);
 9560            if (!ok) {
 9561                state.error << "fasttest.SclNoneOpt.Value: bad Scaled" << eol;
 9562            }
 9563        }
 9564        pmask_qSetBitVal(parent,Value_Present_GetBit(parent),prs);
 9565    }
 9566    (void)pmap;//only to avoid -Wunused-parameter
 9567    return ok;
 9568}
 9569
 9570// --- fasttest.SclNoneOpt..FixEncode
 9571void fasttest::SclNoneOpt_FixEncode(cstring& buf, fasttest::SclNoneOpt& parent, char soh) {
 9572    if (Value_PresentQ(parent)) {
 9573        buf << "1=" << parent.Value << soh;
 9574    }
 9575}
 9576
 9577// --- fasttest.SecondSeq..ReadFieldMaybe
 9578bool fasttest::SecondSeq_ReadFieldMaybe(fasttest::SecondSeq& parent, algo::strptr field, algo::strptr strval) {
 9579    bool retval = true;
 9580    fasttest::FieldId field_id;
 9581    (void)value_SetStrptrMaybe(field_id,field);
 9582    switch(field_id) {
 9583        case fasttest_FieldId_Value2: {
 9584            retval = u32_ReadStrptrMaybe(parent.Value2, strval);
 9585            break;
 9586        }
 9587        default: break;
 9588    }
 9589    if (!retval) {
 9590        algo_lib::AppendErrtext("attr",field);
 9591    }
 9592    return retval;
 9593}
 9594
 9595// --- fasttest.SecondSeq..ReadStrptrMaybe
 9596// Read fields of fasttest::SecondSeq from an ascii string.
 9597// The format of the string is an ssim Tuple
 9598bool fasttest::SecondSeq_ReadStrptrMaybe(fasttest::SecondSeq &parent, algo::strptr in_str) {
 9599    bool retval = true;
 9600    retval = algo::StripTypeTag(in_str, "fasttest.SecondSeq");
 9601    ind_beg(algo::Attr_curs, attr, in_str) {
 9602        retval = retval && SecondSeq_ReadFieldMaybe(parent, attr.name, attr.value);
 9603    }ind_end;
 9604    return retval;
 9605}
 9606
 9607// --- fasttest.SecondSeq..Print
 9608// print string representation of ROW to string STR
 9609// cfmt:fasttest.SecondSeq.String  printfmt:Tuple
 9610void fasttest::SecondSeq_Print(fasttest::SecondSeq& row, algo::cstring& str) {
 9611    algo::tempstr temp;
 9612    str << "fasttest.SecondSeq";
 9613
 9614    u32_Print(row.Value2, temp);
 9615    PrintAttrSpaceReset(str,"Value2", temp);
 9616}
 9617
 9618// --- fasttest.SecondSeq..FastEncode
 9619void fasttest::SecondSeq_FastEncode(algo::ByteAry& buf, FastState& state, fasttest::SecondSeq& parent) {
 9620    // Value2 unsigned none mandatory
 9621    lib_fast::EncodeUnsigned(buf,parent.Value2,false);
 9622    (void)state;//only to avoid -Wunused-parameter
 9623}
 9624
 9625// --- fasttest.SecondSeq..FastDecode
 9626bool fasttest::SecondSeq_FastDecode(algo::memptr& from, FastState& state, fasttest::SecondSeq& parent) {
 9627    bool ok = true;
 9628    // Value2 unsigned none mandatory
 9629    if (ok) {
 9630        ok = lib_fast::DecodeUnsigned(from,parent.Value2,false);
 9631        if (!ok) {
 9632            state.error << "fasttest.SecondSeq.Value2: bad Unsigned" << eol;
 9633        }
 9634    }
 9635    return ok;
 9636}
 9637
 9638// --- fasttest.SecondSeq..FixEncode
 9639void fasttest::SecondSeq_FixEncode(cstring& buf, fasttest::SecondSeq& parent, char soh) {
 9640    buf << "5=" << parent.Value2 << soh;
 9641}
 9642
 9643// --- fasttest.SeqOrder.base.CopyOut
 9644// Copy fields out of row
 9645void fasttest::parent_CopyOut(fasttest::SeqOrder &row, fasttest::TemplateHeader &out) {
 9646    // length: field value is computed
 9647    // id: field value is computed
 9648    (void)row;//only to avoid -Wunused-parameter
 9649    (void)out;//only to avoid -Wunused-parameter
 9650}
 9651
 9652// --- fasttest.SeqOrder.FirstSeq.Getary
 9653// Access var-length portion as an aryptr. Length is determined from one of the fields.
 9654algo::aryptr<fasttest::FirstSeq> fasttest::FirstSeq_Getary(fasttest::SeqOrder& parent) {
 9655    return algo::aryptr<fasttest::FirstSeq>(FirstSeq_Addr(parent), FirstSeq_N(parent));
 9656}
 9657
 9658// --- fasttest.SeqOrder.FirstSeq.Addr
 9659fasttest::FirstSeq* fasttest::FirstSeq_Addr(fasttest::SeqOrder& parent) {
 9660    return (fasttest::FirstSeq*)((u8*)&parent + sizeof(fasttest::SeqOrder)); // address of varlen portion
 9661}
 9662
 9663// --- fasttest.SeqOrder.FirstSeq.ReadStrptrMaybe
 9664// Convert string to field. Return success value
 9665bool fasttest::FirstSeq_ReadStrptrMaybe(fasttest::SeqOrder& parent, algo::strptr in_str) {
 9666    bool retval = true;
 9667    if (algo_lib::_db.varlenbuf) {
 9668        fasttest::FirstSeq *FirstSeq_tmp = new(ary_AllocN(*algo_lib::_db.varlenbuf, sizeof(fasttest::FirstSeq)).elems) fasttest::FirstSeq;
 9669        retval = fasttest::FirstSeq_ReadStrptrMaybe(*FirstSeq_tmp, in_str);
 9670    }
 9671    (void)parent;//only to avoid -Wunused-parameter
 9672    return retval;
 9673}
 9674
 9675// --- fasttest.SeqOrder..ReadFieldMaybe
 9676bool fasttest::SeqOrder_ReadFieldMaybe(fasttest::SeqOrder& parent, algo::strptr field, algo::strptr strval) {
 9677    bool retval = true;
 9678    fasttest::FieldId field_id;
 9679    (void)value_SetStrptrMaybe(field_id,algo::Pathcomp(field, ".LL"));
 9680    switch(field_id) {
 9681        case fasttest_FieldId_base: {
 9682            retval = false;
 9683            break;
 9684        }
 9685        case fasttest_FieldId_length: {
 9686            retval = false;
 9687            break;
 9688        }
 9689        case fasttest_FieldId_id: {
 9690            retval = false;
 9691            break;
 9692        }
 9693        case fasttest_FieldId_SecondSeq: {
 9694            retval = fasttest::SecondSeq_ReadStrptrMaybe(parent.SecondSeq, strval);
 9695            break;
 9696        }
 9697        case fasttest_FieldId_Value3: {
 9698            retval = u32_ReadStrptrMaybe(parent.Value3, strval);
 9699            break;
 9700        }
 9701        case fasttest_FieldId_FirstSeq: {
 9702            retval = FirstSeq_ReadStrptrMaybe(parent, strval);
 9703            break;
 9704        }
 9705        default: break;
 9706    }
 9707    if (!retval) {
 9708        algo_lib::AppendErrtext("attr",field);
 9709    }
 9710    return retval;
 9711}
 9712
 9713// --- fasttest.SeqOrder..ReadStrptrMaybe
 9714// Any varlen fields are returned in algo_lib::_db.varlenbuf if set
 9715// Read fields of fasttest::SeqOrder from an ascii string.
 9716// The format of the string is an ssim Tuple
 9717bool fasttest::SeqOrder_ReadStrptrMaybe(fasttest::SeqOrder &parent, algo::strptr in_str) {
 9718    bool retval = true;
 9719    retval = algo::StripTypeTag(in_str, "fasttest.SeqOrder");
 9720    ind_beg(algo::Attr_curs, attr, in_str) {
 9721        retval = retval && SeqOrder_ReadFieldMaybe(parent, attr.name, attr.value);
 9722    }ind_end;
 9723    return retval;
 9724}
 9725
 9726// --- fasttest.SeqOrder..Print
 9727// print string representation of ROW to string STR
 9728// cfmt:fasttest.SeqOrder.String  printfmt:Tuple
 9729void fasttest::SeqOrder_Print(fasttest::SeqOrder& row, algo::cstring& str) {
 9730    algo::tempstr temp;
 9731    str << "fasttest.SeqOrder";
 9732
 9733    fasttest::SecondSeq_Print(row.SecondSeq, temp);
 9734    PrintAttrSpaceReset(str,"SecondSeq", temp);
 9735
 9736    u32_Print(row.Value3, temp);
 9737    PrintAttrSpaceReset(str,"Value3", temp);
 9738
 9739    ind_beg(SeqOrder_FirstSeq_curs,FirstSeq,row) {
 9740        fasttest::FirstSeq_Print(FirstSeq, temp);
 9741        tempstr name;
 9742        name << "FirstSeq.";
 9743        name << ind_curs(FirstSeq).index;
 9744        PrintAttrSpaceReset(str, name, temp);
 9745    }ind_end;
 9746}
 9747
 9748// --- fasttest.SeqOrder..FastEncode
 9749void fasttest::SeqOrder_FastEncode(algo::ByteAry& buf, FastState& state, fasttest::SeqOrder& parent) {
 9750    int index = ary_N(buf);
 9751    u64 pmap(0);
 9752    if (!tid_AssignedQ(state) || parent.id != state.tid) {
 9753        lib_fast::EncodeUnsigned(buf,parent.id,false);
 9754        lib_fast::SetPmapBit(pmap,0);
 9755    }
 9756    tid_SetAssigned(state);
 9757    state.tid = parent.id;
 9758    // FirstSeq sequence none mandatory
 9759    {
 9760        u32 length = FirstSeq_N(parent);
 9761        lib_fast::EncodeUnsigned(buf,length,false);
 9762        ind_beg(SeqOrder_FirstSeq_curs,elem,parent) {
 9763            FirstSeq_FastEncode(buf,state,elem);
 9764        }ind_end;
 9765    }
 9766    // SecondSeq sequence none mandatory
 9767    SecondSeq_FastEncode(buf,state,parent.SecondSeq);
 9768    // Value3 unsigned none mandatory
 9769    lib_fast::EncodeUnsigned(buf,parent.Value3,false);
 9770    lib_fast::InsertPmap(buf,index,pmap);
 9771}
 9772
 9773// --- fasttest.SeqOrder..FastDecode
 9774bool fasttest::SeqOrder_FastDecode(algo::memptr& from, u64 pmap, FastState& state, fasttest::SeqOrder& parent) {
 9775    bool ok = true;
 9776    // FirstSeq sequence none mandatory
 9777    if (ok) {
 9778        u32 length(0);
 9779        ok = lib_fast::DecodeUnsigned(from,length,false);
 9780        if (!ok) {
 9781            state.error << "fasttest.SeqOrder.FirstSeq: bad Unsigned" << eol;
 9782        }
 9783        if (!ok) {
 9784            state.error << "fasttest.SeqOrder.FirstSeq: bad length" << eol;
 9785        }
 9786        for (unsigned i=0; ok && i<length; ++i) {
 9787            FirstSeq &seq = *new(ary_AllocN(lib_fast::_db.varlen,sizeof seq).elems) FirstSeq;
 9788            ok = FirstSeq_FastDecode(from,state,seq);
 9789            if (!ok) {
 9790                state.error << "fasttest.SeqOrder.FirstSeq: element #"<< i+1 << eol;
 9791            }
 9792        }
 9793    }
 9794    // SecondSeq sequence none mandatory
 9795    if (ok) {
 9796        ok = SecondSeq_FastDecode(from,state,parent.SecondSeq);
 9797    }
 9798    // Value3 unsigned none mandatory
 9799    if (ok) {
 9800        ok = lib_fast::DecodeUnsigned(from,parent.Value3,false);
 9801        if (!ok) {
 9802            state.error << "fasttest.SeqOrder.Value3: bad Unsigned" << eol;
 9803        }
 9804    }
 9805    (void)pmap;//only to avoid -Wunused-parameter
 9806    return ok;
 9807}
 9808
 9809// --- fasttest.SeqOrder..FixEncode
 9810void fasttest::SeqOrder_FixEncode(cstring& buf, fasttest::SeqOrder& parent, char soh) {
 9811    ind_beg(SeqOrder_FirstSeq_curs,elem,parent) {
 9812        FirstSeq_FixEncode(buf,elem,soh);
 9813    }ind_end;
 9814    buf << "4=1" << soh;
 9815    buf << "3=" << parent.SecondSeq << soh;
 9816    buf << "6=" << parent.Value3 << soh;
 9817}
 9818
 9819// --- fasttest.SeqSgmOpt.base.CopyOut
 9820// Copy fields out of row
 9821void fasttest::parent_CopyOut(fasttest::SeqSgmOpt &row, fasttest::TemplateHeader &out) {
 9822    // length: field value is computed
 9823    // id: field value is computed
 9824    (void)row;//only to avoid -Wunused-parameter
 9825    (void)out;//only to avoid -Wunused-parameter
 9826}
 9827
 9828// --- fasttest.SeqSgmOpt.OptSgmSeq.Getary
 9829// Access var-length portion as an aryptr. Length is determined from one of the fields.
 9830algo::aryptr<fasttest::OptSgmSeq> fasttest::OptSgmSeq_Getary(fasttest::SeqSgmOpt& parent) {
 9831    return algo::aryptr<fasttest::OptSgmSeq>(OptSgmSeq_Addr(parent), OptSgmSeq_N(parent));
 9832}
 9833
 9834// --- fasttest.SeqSgmOpt.OptSgmSeq.Addr
 9835fasttest::OptSgmSeq* fasttest::OptSgmSeq_Addr(fasttest::SeqSgmOpt& parent) {
 9836    return (fasttest::OptSgmSeq*)((u8*)&parent + sizeof(fasttest::SeqSgmOpt)); // address of varlen portion
 9837}
 9838
 9839// --- fasttest.SeqSgmOpt.OptSgmSeq.ReadStrptrMaybe
 9840// Convert string to field. Return success value
 9841bool fasttest::OptSgmSeq_ReadStrptrMaybe(fasttest::SeqSgmOpt& parent, algo::strptr in_str) {
 9842    bool retval = true;
 9843    if (algo_lib::_db.varlenbuf) {
 9844        fasttest::OptSgmSeq *OptSgmSeq_tmp = new(ary_AllocN(*algo_lib::_db.varlenbuf, sizeof(fasttest::OptSgmSeq)).elems) fasttest::OptSgmSeq;
 9845        retval = fasttest::OptSgmSeq_ReadStrptrMaybe(*OptSgmSeq_tmp, in_str);
 9846    }
 9847    (void)parent;//only to avoid -Wunused-parameter
 9848    return retval;
 9849}
 9850
 9851// --- fasttest.SeqSgmOpt..ReadFieldMaybe
 9852bool fasttest::SeqSgmOpt_ReadFieldMaybe(fasttest::SeqSgmOpt& parent, algo::strptr field, algo::strptr strval) {
 9853    bool retval = true;
 9854    fasttest::FieldId field_id;
 9855    (void)value_SetStrptrMaybe(field_id,algo::Pathcomp(field, ".LL"));
 9856    switch(field_id) {
 9857        case fasttest_FieldId_base: {
 9858            retval = false;
 9859            break;
 9860        }
 9861        case fasttest_FieldId_length: {
 9862            retval = false;
 9863            break;
 9864        }
 9865        case fasttest_FieldId_id: {
 9866            retval = false;
 9867            break;
 9868        }
 9869        case fasttest_FieldId_OptSgmSeq: {
 9870            retval = OptSgmSeq_ReadStrptrMaybe(parent, strval);
 9871            break;
 9872        }
 9873        default: break;
 9874    }
 9875    if (!retval) {
 9876        algo_lib::AppendErrtext("attr",field);
 9877    }
 9878    return retval;
 9879}
 9880
 9881// --- fasttest.SeqSgmOpt..ReadStrptrMaybe
 9882// Any varlen fields are returned in algo_lib::_db.varlenbuf if set
 9883// Read fields of fasttest::SeqSgmOpt from an ascii string.
 9884// The format of the string is an ssim Tuple
 9885bool fasttest::SeqSgmOpt_ReadStrptrMaybe(fasttest::SeqSgmOpt &parent, algo::strptr in_str) {
 9886    bool retval = true;
 9887    retval = algo::StripTypeTag(in_str, "fasttest.SeqSgmOpt");
 9888    ind_beg(algo::Attr_curs, attr, in_str) {
 9889        retval = retval && SeqSgmOpt_ReadFieldMaybe(parent, attr.name, attr.value);
 9890    }ind_end;
 9891    return retval;
 9892}
 9893
 9894// --- fasttest.SeqSgmOpt..Print
 9895// print string representation of ROW to string STR
 9896// cfmt:fasttest.SeqSgmOpt.String  printfmt:Tuple
 9897void fasttest::SeqSgmOpt_Print(fasttest::SeqSgmOpt& row, algo::cstring& str) {
 9898    algo::tempstr temp;
 9899    str << "fasttest.SeqSgmOpt";
 9900
 9901    ind_beg(SeqSgmOpt_OptSgmSeq_curs,OptSgmSeq,row) {
 9902        fasttest::OptSgmSeq_Print(OptSgmSeq, temp);
 9903        tempstr name;
 9904        name << "OptSgmSeq.";
 9905        name << ind_curs(OptSgmSeq).index;
 9906        PrintAttrSpaceReset(str, name, temp);
 9907    }ind_end;
 9908}
 9909
 9910// --- fasttest.SeqSgmOpt..FastEncode
 9911void fasttest::SeqSgmOpt_FastEncode(algo::ByteAry& buf, FastState& state, fasttest::SeqSgmOpt& parent) {
 9912    int index = ary_N(buf);
 9913    u64 pmap(0);
 9914    if (!tid_AssignedQ(state) || parent.id != state.tid) {
 9915        lib_fast::EncodeUnsigned(buf,parent.id,false);
 9916        lib_fast::SetPmapBit(pmap,0);
 9917    }
 9918    tid_SetAssigned(state);
 9919    state.tid = parent.id;
 9920    // OptSgmSeq sequence none optional
 9921    {
 9922        u32 length = OptSgmSeq_N(parent);
 9923        if (length) {
 9924            lib_fast::EncodeUnsigned(buf,length,true);
 9925        } else {
 9926            lib_fast::EncodeNull(buf);
 9927        }
 9928        ind_beg(SeqSgmOpt_OptSgmSeq_curs,elem,parent) {
 9929            OptSgmSeq_FastEncode(buf,state,elem);
 9930        }ind_end;
 9931    }
 9932    lib_fast::InsertPmap(buf,index,pmap);
 9933}
 9934
 9935// --- fasttest.SeqSgmOpt..FastDecode
 9936bool fasttest::SeqSgmOpt_FastDecode(algo::memptr& from, u64 pmap, FastState& state, fasttest::SeqSgmOpt& parent) {
 9937    bool ok = true;
 9938    // OptSgmSeq sequence none optional
 9939    if (ok) {
 9940        u32 length(0);
 9941        bool prs = !lib_fast::DecodeNull(from);
 9942        if (prs) {
 9943            ok = lib_fast::DecodeUnsigned(from,length,true);
 9944            if (!ok) {
 9945                state.error << "fasttest.SeqSgmOpt.OptSgmSeq: bad Unsigned" << eol;
 9946            }
 9947        }
 9948        ;
 9949        if (!ok) {
 9950            state.error << "fasttest.SeqSgmOpt.OptSgmSeq: bad length" << eol;
 9951        }
 9952        length = prs ? length : 0;
 9953        for (unsigned i=0; ok && i<length; ++i) {
 9954            OptSgmSeq &seq = *new(ary_AllocN(lib_fast::_db.varlen,sizeof seq).elems) OptSgmSeq;
 9955            ok = OptSgmSeq_FastDecode(from,state,seq);
 9956            if (!ok) {
 9957                state.error << "fasttest.SeqSgmOpt.OptSgmSeq: element #"<< i+1 << eol;
 9958            }
 9959        }
 9960    }
 9961    (void)pmap;//only to avoid -Wunused-parameter
 9962    (void)parent;//only to avoid -Wunused-parameter
 9963    return ok;
 9964}
 9965
 9966// --- fasttest.SeqSgmOpt..FixEncode
 9967void fasttest::SeqSgmOpt_FixEncode(cstring& buf, fasttest::SeqSgmOpt& parent, char soh) {
 9968    ind_beg(SeqSgmOpt_OptSgmSeq_curs,elem,parent) {
 9969        OptSgmSeq_FixEncode(buf,elem,soh);
 9970    }ind_end;
 9971}
 9972
 9973// --- fasttest.TrvSeq..ReadFieldMaybe
 9974bool fasttest::TrvSeq_ReadFieldMaybe(fasttest::TrvSeq& parent, algo::strptr field, algo::strptr strval) {
 9975    bool retval = true;
 9976    fasttest::FieldId field_id;
 9977    (void)value_SetStrptrMaybe(field_id,field);
 9978    switch(field_id) {
 9979        case fasttest_FieldId_Value: {
 9980            retval = u32_ReadStrptrMaybe(parent.Value, strval);
 9981            break;
 9982        }
 9983        default: break;
 9984    }
 9985    if (!retval) {
 9986        algo_lib::AppendErrtext("attr",field);
 9987    }
 9988    return retval;
 9989}
 9990
 9991// --- fasttest.TrvSeq..ReadStrptrMaybe
 9992// Read fields of fasttest::TrvSeq from an ascii string.
 9993// The format of the string is an ssim Tuple
 9994bool fasttest::TrvSeq_ReadStrptrMaybe(fasttest::TrvSeq &parent, algo::strptr in_str) {
 9995    bool retval = true;
 9996    retval = algo::StripTypeTag(in_str, "fasttest.TrvSeq");
 9997    ind_beg(algo::Attr_curs, attr, in_str) {
 9998        retval = retval && TrvSeq_ReadFieldMaybe(parent, attr.name, attr.value);
 9999    }ind_end;
10000    return retval;
10001}
10002
10003// --- fasttest.TrvSeq..Print
10004// print string representation of ROW to string STR
10005// cfmt:fasttest.TrvSeq.String  printfmt:Tuple
10006void fasttest::TrvSeq_Print(fasttest::TrvSeq& row, algo::cstring& str) {
10007    algo::tempstr temp;
10008    str << "fasttest.TrvSeq";
10009
10010    u32_Print(row.Value, temp);
10011    PrintAttrSpaceReset(str,"Value", temp);
10012}
10013
10014// --- fasttest.TrvSeq..FastEncode
10015void fasttest::TrvSeq_FastEncode(algo::ByteAry& buf, FastState& state, fasttest::TrvSeq& parent) {
10016    // Value unsigned none mandatory
10017    lib_fast::EncodeUnsigned(buf,parent.Value,false);
10018    (void)state;//only to avoid -Wunused-parameter
10019}
10020
10021// --- fasttest.TrvSeq..FastDecode
10022bool fasttest::TrvSeq_FastDecode(algo::memptr& from, FastState& state, fasttest::TrvSeq& parent) {
10023    bool ok = true;
10024    // Value unsigned none mandatory
10025    if (ok) {
10026        ok = lib_fast::DecodeUnsigned(from,parent.Value,false);
10027        if (!ok) {
10028            state.error << "fasttest.TrvSeq.Value: bad Unsigned" << eol;
10029        }
10030    }
10031    return ok;
10032}
10033
10034// --- fasttest.TrvSeq..FixEncode
10035void fasttest::TrvSeq_FixEncode(cstring& buf, fasttest::TrvSeq& parent, char soh) {
10036    buf << "2=" << parent.Value << soh;
10037}
10038
10039// --- fasttest.SeqTrv.base.CopyOut
10040// Copy fields out of row
10041void fasttest::parent_CopyOut(fasttest::SeqTrv &row, fasttest::TemplateHeader &out) {
10042    // length: field value is computed
10043    // id: field value is computed
10044    (void)row;//only to avoid -Wunused-parameter
10045    (void)out;//only to avoid -Wunused-parameter
10046}
10047
10048// --- fasttest.SeqTrv.TrvSeq.Getary
10049// Access var-length portion as an aryptr. Length is determined from one of the fields.
10050algo::aryptr<fasttest::TrvSeq> fasttest::TrvSeq_Getary(fasttest::SeqTrv& parent) {
10051    return algo::aryptr<fasttest::TrvSeq>(TrvSeq_Addr(parent), TrvSeq_N(parent));
10052}
10053
10054// --- fasttest.SeqTrv.TrvSeq.Addr
10055fasttest::TrvSeq* fasttest::TrvSeq_Addr(fasttest::SeqTrv& parent) {
10056    return (fasttest::TrvSeq*)((u8*)&parent + sizeof(fasttest::SeqTrv)); // address of varlen portion
10057}
10058
10059// --- fasttest.SeqTrv.TrvSeq.ReadStrptrMaybe
10060// Convert string to field. Return success value
10061bool fasttest::TrvSeq_ReadStrptrMaybe(fasttest::SeqTrv& parent, algo::strptr in_str) {
10062    bool retval = true;
10063    if (algo_lib::_db.varlenbuf) {
10064        fasttest::TrvSeq *TrvSeq_tmp = new(ary_AllocN(*algo_lib::_db.varlenbuf, sizeof(fasttest::TrvSeq)).elems) fasttest::TrvSeq;
10065        retval = fasttest::TrvSeq_ReadStrptrMaybe(*TrvSeq_tmp, in_str);
10066    }
10067    (void)parent;//only to avoid -Wunused-parameter
10068    return retval;
10069}
10070
10071// --- fasttest.SeqTrv..ReadFieldMaybe
10072bool fasttest::SeqTrv_ReadFieldMaybe(fasttest::SeqTrv& parent, algo::strptr field, algo::strptr strval) {
10073    bool retval = true;
10074    fasttest::FieldId field_id;
10075    (void)value_SetStrptrMaybe(field_id,algo::Pathcomp(field, ".LL"));
10076    switch(field_id) {
10077        case fasttest_FieldId_base: {
10078            retval = false;
10079            break;
10080        }
10081        case fasttest_FieldId_length: {
10082            retval = false;
10083            break;
10084        }
10085        case fasttest_FieldId_id: {
10086            retval = false;
10087            break;
10088        }
10089        case fasttest_FieldId_TrvSeq: {
10090            retval = TrvSeq_ReadStrptrMaybe(parent, strval);
10091            break;
10092        }
10093        default: break;
10094    }
10095    if (!retval) {
10096        algo_lib::AppendErrtext("attr",field);
10097    }
10098    return retval;
10099}
10100
10101// --- fasttest.SeqTrv..ReadStrptrMaybe
10102// Any varlen fields are returned in algo_lib::_db.varlenbuf if set
10103// Read fields of fasttest::SeqTrv from an ascii string.
10104// The format of the string is an ssim Tuple
10105bool fasttest::SeqTrv_ReadStrptrMaybe(fasttest::SeqTrv &parent, algo::strptr in_str) {
10106    bool retval = true;
10107    retval = algo::StripTypeTag(in_str, "fasttest.SeqTrv");
10108    ind_beg(algo::Attr_curs, attr, in_str) {
10109        retval = retval && SeqTrv_ReadFieldMaybe(parent, attr.name, attr.value);
10110    }ind_end;
10111    return retval;
10112}
10113
10114// --- fasttest.SeqTrv..Print
10115// print string representation of ROW to string STR
10116// cfmt:fasttest.SeqTrv.String  printfmt:Tuple
10117void fasttest::SeqTrv_Print(fasttest::SeqTrv& row, algo::cstring& str) {
10118    algo::tempstr temp;
10119    str << "fasttest.SeqTrv";
10120
10121    ind_beg(SeqTrv_TrvSeq_curs,TrvSeq,row) {
10122        fasttest::TrvSeq_Print(TrvSeq, temp);
10123        tempstr name;
10124        name << "TrvSeq.";
10125        name << ind_curs(TrvSeq).index;
10126        PrintAttrSpaceReset(str, name, temp);
10127    }ind_end;
10128}
10129
10130// --- fasttest.SeqTrv..FastEncode
10131void fasttest::SeqTrv_FastEncode(algo::ByteAry& buf, FastState& state, fasttest::SeqTrv& parent) {
10132    int index = ary_N(buf);
10133    u64 pmap(0);
10134    if (!tid_AssignedQ(state) || parent.id != state.tid) {
10135        lib_fast::EncodeUnsigned(buf,parent.id,false);
10136        lib_fast::SetPmapBit(pmap,0);
10137    }
10138    tid_SetAssigned(state);
10139    state.tid = parent.id;
10140    // TrvSeq sequence none mandatory
10141    {
10142        u32 length = TrvSeq_N(parent);
10143        lib_fast::EncodeUnsigned(buf,length,false);
10144        ind_beg(SeqTrv_TrvSeq_curs,elem,parent) {
10145            TrvSeq_FastEncode(buf,state,elem);
10146        }ind_end;
10147    }
10148    lib_fast::InsertPmap(buf,index,pmap);
10149}
10150
10151// --- fasttest.SeqTrv..FastDecode
10152bool fasttest::SeqTrv_FastDecode(algo::memptr& from, u64 pmap, FastState& state, fasttest::SeqTrv& parent) {
10153    bool ok = true;
10154    // TrvSeq sequence none mandatory
10155    if (ok) {
10156        u32 length(0);
10157        ok = lib_fast::DecodeUnsigned(from,length,false);
10158        if (!ok) {
10159            state.error << "fasttest.SeqTrv.TrvSeq: bad Unsigned" << eol;
10160        }
10161        if (!ok) {
10162            state.error << "fasttest.SeqTrv.TrvSeq: bad length" << eol;
10163        }
10164        for (unsigned i=0; ok && i<length; ++i) {
10165            TrvSeq &seq = *new(ary_AllocN(lib_fast::_db.varlen,sizeof seq).elems) TrvSeq;
10166            ok = TrvSeq_FastDecode(from,state,seq);
10167            if (!ok) {
10168                state.error << "fasttest.SeqTrv.TrvSeq: element #"<< i+1 << eol;
10169            }
10170        }
10171    }
10172    (void)pmap;//only to avoid -Wunused-parameter
10173    (void)parent;//only to avoid -Wunused-parameter
10174    return ok;
10175}
10176
10177// --- fasttest.SeqTrv..FixEncode
10178void fasttest::SeqTrv_FixEncode(cstring& buf, fasttest::SeqTrv& parent, char soh) {
10179    ind_beg(SeqTrv_TrvSeq_curs,elem,parent) {
10180        TrvSeq_FixEncode(buf,elem,soh);
10181    }ind_end;
10182}
10183
10184// --- fasttest.TrvSeqLenConst..ReadFieldMaybe
10185bool fasttest::TrvSeqLenConst_ReadFieldMaybe(fasttest::TrvSeqLenConst& parent, algo::strptr field, algo::strptr strval) {
10186    bool retval = true;
10187    fasttest::FieldId field_id;
10188    (void)value_SetStrptrMaybe(field_id,field);
10189    switch(field_id) {
10190        case fasttest_FieldId_Value: {
10191            retval = u32_ReadStrptrMaybe(parent.Value, strval);
10192            break;
10193        }
10194        default: break;
10195    }
10196    if (!retval) {
10197        algo_lib::AppendErrtext("attr",field);
10198    }
10199    return retval;
10200}
10201
10202// --- fasttest.TrvSeqLenConst..ReadStrptrMaybe
10203// Read fields of fasttest::TrvSeqLenConst from an ascii string.
10204// The format of the string is an ssim Tuple
10205bool fasttest::TrvSeqLenConst_ReadStrptrMaybe(fasttest::TrvSeqLenConst &parent, algo::strptr in_str) {
10206    bool retval = true;
10207    retval = algo::StripTypeTag(in_str, "fasttest.TrvSeqLenConst");
10208    ind_beg(algo::Attr_curs, attr, in_str) {
10209        retval = retval && TrvSeqLenConst_ReadFieldMaybe(parent, attr.name, attr.value);
10210    }ind_end;
10211    return retval;
10212}
10213
10214// --- fasttest.TrvSeqLenConst..Print
10215// print string representation of ROW to string STR
10216// cfmt:fasttest.TrvSeqLenConst.String  printfmt:Tuple
10217void fasttest::TrvSeqLenConst_Print(fasttest::TrvSeqLenConst& row, algo::cstring& str) {
10218    algo::tempstr temp;
10219    str << "fasttest.TrvSeqLenConst";
10220
10221    u32_Print(row.Value, temp);
10222    PrintAttrSpaceReset(str,"Value", temp);
10223}
10224
10225// --- fasttest.TrvSeqLenConst..FastEncode
10226void fasttest::TrvSeqLenConst_FastEncode(algo::ByteAry& buf, FastState& state, fasttest::TrvSeqLenConst& parent) {
10227    // Value unsigned none mandatory
10228    lib_fast::EncodeUnsigned(buf,parent.Value,false);
10229    (void)state;//only to avoid -Wunused-parameter
10230}
10231
10232// --- fasttest.TrvSeqLenConst..FastDecode
10233bool fasttest::TrvSeqLenConst_FastDecode(algo::memptr& from, FastState& state, fasttest::TrvSeqLenConst& parent) {
10234    bool ok = true;
10235    // Value unsigned none mandatory
10236    if (ok) {
10237        ok = lib_fast::DecodeUnsigned(from,parent.Value,false);
10238        if (!ok) {
10239            state.error << "fasttest.TrvSeqLenConst.Value: bad Unsigned" << eol;
10240        }
10241    }
10242    return ok;
10243}
10244
10245// --- fasttest.TrvSeqLenConst..FixEncode
10246void fasttest::TrvSeqLenConst_FixEncode(cstring& buf, fasttest::TrvSeqLenConst& parent, char soh) {
10247    buf << "3=" << parent.Value << soh;
10248}
10249
10250// --- fasttest.SeqTrvLenConst.base.CopyOut
10251// Copy fields out of row
10252void fasttest::parent_CopyOut(fasttest::SeqTrvLenConst &row, fasttest::TemplateHeader &out) {
10253    // length: field value is computed
10254    // id: field value is computed
10255    (void)row;//only to avoid -Wunused-parameter
10256    (void)out;//only to avoid -Wunused-parameter
10257}
10258
10259// --- fasttest.SeqTrvLenConst..ReadFieldMaybe
10260bool fasttest::SeqTrvLenConst_ReadFieldMaybe(fasttest::SeqTrvLenConst& parent, algo::strptr field, algo::strptr strval) {
10261    bool retval = true;
10262    fasttest::FieldId field_id;
10263    (void)value_SetStrptrMaybe(field_id,field);
10264    switch(field_id) {
10265        case fasttest_FieldId_base: {
10266            retval = false;
10267            break;
10268        }
10269        case fasttest_FieldId_length: {
10270            retval = false;
10271            break;
10272        }
10273        case fasttest_FieldId_id: {
10274            retval = false;
10275            break;
10276        }
10277        case fasttest_FieldId_TrvSeqLenConst: {
10278            retval = fasttest::TrvSeqLenConst_ReadStrptrMaybe(parent.TrvSeqLenConst, strval);
10279            break;
10280        }
10281        default: break;
10282    }
10283    if (!retval) {
10284        algo_lib::AppendErrtext("attr",field);
10285    }
10286    return retval;
10287}
10288
10289// --- fasttest.SeqTrvLenConst..ReadStrptrMaybe
10290// Read fields of fasttest::SeqTrvLenConst from an ascii string.
10291// The format of the string is an ssim Tuple
10292bool fasttest::SeqTrvLenConst_ReadStrptrMaybe(fasttest::SeqTrvLenConst &parent, algo::strptr in_str) {
10293    bool retval = true;
10294    retval = algo::StripTypeTag(in_str, "fasttest.SeqTrvLenConst");
10295    ind_beg(algo::Attr_curs, attr, in_str) {
10296        retval = retval && SeqTrvLenConst_ReadFieldMaybe(parent, attr.name, attr.value);
10297    }ind_end;
10298    return retval;
10299}
10300
10301// --- fasttest.SeqTrvLenConst..Print
10302// print string representation of ROW to string STR
10303// cfmt:fasttest.SeqTrvLenConst.String  printfmt:Tuple
10304void fasttest::SeqTrvLenConst_Print(fasttest::SeqTrvLenConst& row, algo::cstring& str) {
10305    algo::tempstr temp;
10306    str << "fasttest.SeqTrvLenConst";
10307
10308    fasttest::TrvSeqLenConst_Print(row.TrvSeqLenConst, temp);
10309    PrintAttrSpaceReset(str,"TrvSeqLenConst", temp);
10310}
10311
10312// --- fasttest.SeqTrvLenConst..FastEncode
10313void fasttest::SeqTrvLenConst_FastEncode(algo::ByteAry& buf, FastState& state, fasttest::SeqTrvLenConst& parent) {
10314    int index = ary_N(buf);
10315    u64 pmap(0);
10316    if (!tid_AssignedQ(state) || parent.id != state.tid) {
10317        lib_fast::EncodeUnsigned(buf,parent.id,false);
10318        lib_fast::SetPmapBit(pmap,0);
10319    }
10320    tid_SetAssigned(state);
10321    state.tid = parent.id;
10322    // TrvSeqLenConst sequence none mandatory
10323    TrvSeqLenConst_FastEncode(buf,state,parent.TrvSeqLenConst);
10324    lib_fast::InsertPmap(buf,index,pmap);
10325}
10326
10327// --- fasttest.SeqTrvLenConst..FastDecode
10328bool fasttest::SeqTrvLenConst_FastDecode(algo::memptr& from, u64 pmap, FastState& state, fasttest::SeqTrvLenConst& parent) {
10329    bool ok = true;
10330    // TrvSeqLenConst sequence none mandatory
10331    if (ok) {
10332        ok = TrvSeqLenConst_FastDecode(from,state,parent.TrvSeqLenConst);
10333    }
10334    (void)pmap;//only to avoid -Wunused-parameter
10335    return ok;
10336}
10337
10338// --- fasttest.SeqTrvLenConst..FixEncode
10339void fasttest::SeqTrvLenConst_FixEncode(cstring& buf, fasttest::SeqTrvLenConst& parent, char soh) {
10340    buf << "2=1" << soh;
10341    buf << "1=" << parent.TrvSeqLenConst << soh;
10342}
10343
10344// --- fasttest.TrvSeqLenConstOpt..ReadFieldMaybe
10345bool fasttest::TrvSeqLenConstOpt_ReadFieldMaybe(fasttest::TrvSeqLenConstOpt& parent, algo::strptr field, algo::strptr strval) {
10346    bool retval = true;
10347    fasttest::FieldId field_id;
10348    (void)value_SetStrptrMaybe(field_id,field);
10349    switch(field_id) {
10350        case fasttest_FieldId_Value: {
10351            retval = u32_ReadStrptrMaybe(parent.Value, strval);
10352            break;
10353        }
10354        default: break;
10355    }
10356    if (!retval) {
10357        algo_lib::AppendErrtext("attr",field);
10358    }
10359    return retval;
10360}
10361
10362// --- fasttest.TrvSeqLenConstOpt..ReadStrptrMaybe
10363// Read fields of fasttest::TrvSeqLenConstOpt from an ascii string.
10364// The format of the string is an ssim Tuple
10365bool fasttest::TrvSeqLenConstOpt_ReadStrptrMaybe(fasttest::TrvSeqLenConstOpt &parent, algo::strptr in_str) {
10366    bool retval = true;
10367    retval = algo::StripTypeTag(in_str, "fasttest.TrvSeqLenConstOpt");
10368    ind_beg(algo::Attr_curs, attr, in_str) {
10369        retval = retval && TrvSeqLenConstOpt_ReadFieldMaybe(parent, attr.name, attr.value);
10370    }ind_end;
10371    return retval;
10372}
10373
10374// --- fasttest.TrvSeqLenConstOpt..Print
10375// print string representation of ROW to string STR
10376// cfmt:fasttest.TrvSeqLenConstOpt.String  printfmt:Tuple
10377void fasttest::TrvSeqLenConstOpt_Print(fasttest::TrvSeqLenConstOpt& row, algo::cstring& str) {
10378    algo::tempstr temp;
10379    str << "fasttest.TrvSeqLenConstOpt";
10380
10381    u32_Print(row.Value, temp);
10382    PrintAttrSpaceReset(str,"Value", temp);
10383}
10384
10385// --- fasttest.TrvSeqLenConstOpt..FastEncode
10386void fasttest::TrvSeqLenConstOpt_FastEncode(algo::ByteAry& buf, FastState& state, fasttest::TrvSeqLenConstOpt& parent) {
10387    // Value unsigned none mandatory
10388    lib_fast::EncodeUnsigned(buf,parent.Value,false);
10389    (void)state;//only to avoid -Wunused-parameter
10390}
10391
10392// --- fasttest.TrvSeqLenConstOpt..FastDecode
10393bool fasttest::TrvSeqLenConstOpt_FastDecode(algo::memptr& from, FastState& state, fasttest::TrvSeqLenConstOpt& parent) {
10394    bool ok = true;
10395    // Value unsigned none mandatory
10396    if (ok) {
10397        ok = lib_fast::DecodeUnsigned(from,parent.Value,false);
10398        if (!ok) {
10399            state.error << "fasttest.TrvSeqLenConstOpt.Value: bad Unsigned" << eol;
10400        }
10401    }
10402    return ok;
10403}
10404
10405// --- fasttest.TrvSeqLenConstOpt..FixEncode
10406void fasttest::TrvSeqLenConstOpt_FixEncode(cstring& buf, fasttest::TrvSeqLenConstOpt& parent, char soh) {
10407    buf << "3=" << parent.Value << soh;
10408}
10409
10410// --- fasttest.SeqTrvLenConstOpt.base.CopyOut
10411// Copy fields out of row
10412void fasttest::parent_CopyOut(fasttest::SeqTrvLenConstOpt &row, fasttest::TemplateHeader &out) {
10413    // length: field value is computed
10414    // id: field value is computed
10415    (void)row;//only to avoid -Wunused-parameter
10416    (void)out;//only to avoid -Wunused-parameter
10417}
10418
10419// --- fasttest.SeqTrvLenConstOpt.TrvSeqLenConstOpt.ReadStrptrMaybe
10420inline static bool fasttest::TrvSeqLenConstOpt_ReadStrptrMaybe(fasttest::SeqTrvLenConstOpt &parent, algo::strptr in_str) {
10421    bool retval = true;
10422    fasttest::TrvSeqLenConstOpt TrvSeqLenConstOpt_tmp;
10423    retval = fasttest::TrvSeqLenConstOpt_ReadStrptrMaybe(TrvSeqLenConstOpt_tmp, in_str);
10424    if (retval) {
10425        TrvSeqLenConstOpt_Set(parent, TrvSeqLenConstOpt_tmp);
10426    }
10427    return retval;
10428}
10429
10430// --- fasttest.SeqTrvLenConstOpt.pmask_bitcurs.Next
10431// proceed to next item
10432void fasttest::SeqTrvLenConstOpt_pmask_bitcurs_Next(SeqTrvLenConstOpt_pmask_bitcurs &curs) {
10433    ++curs.bit;
10434    int index = curs.bit / 32;
10435    int offset = curs.bit % 32;
10436    for (; index < curs.n_elems; ++index, offset = 0) {
10437        u64 rest = curs.elems[index] >> offset;
10438        if (rest) {
10439            offset += algo::u64_BitScanForward(rest);
10440            break;
10441        }
10442    }
10443    curs.bit = index * 32 + offset;
10444}
10445
10446// --- fasttest.SeqTrvLenConstOpt..ReadFieldMaybe
10447bool fasttest::SeqTrvLenConstOpt_ReadFieldMaybe(fasttest::SeqTrvLenConstOpt& parent, algo::strptr field, algo::strptr strval) {
10448    bool retval = true;
10449    fasttest::FieldId field_id;
10450    (void)value_SetStrptrMaybe(field_id,field);
10451    switch(field_id) {
10452        case fasttest_FieldId_base: {
10453            retval = false;
10454            break;
10455        }
10456        case fasttest_FieldId_length: {
10457            retval = false;
10458            break;
10459        }
10460        case fasttest_FieldId_id: {
10461            retval = false;
10462            break;
10463        }
10464        case fasttest_FieldId_pmask: {
10465            retval = false;
10466            break;
10467        }
10468        case fasttest_FieldId_TrvSeqLenConstOpt: {
10469            retval = TrvSeqLenConstOpt_ReadStrptrMaybe(parent, strval);
10470            if (retval) {
10471                pmask_qSetBit(parent, 0);
10472            }
10473            break;
10474        }
10475        default: break;
10476    }
10477    if (!retval) {
10478        algo_lib::AppendErrtext("attr",field);
10479    }
10480    return retval;
10481}
10482
10483// --- fasttest.SeqTrvLenConstOpt..ReadStrptrMaybe
10484// Read fields of fasttest::SeqTrvLenConstOpt from an ascii string.
10485// The format of the string is an ssim Tuple
10486bool fasttest::SeqTrvLenConstOpt_ReadStrptrMaybe(fasttest::SeqTrvLenConstOpt &parent, algo::strptr in_str) {
10487    bool retval = true;
10488    retval = algo::StripTypeTag(in_str, "fasttest.SeqTrvLenConstOpt");
10489    ind_beg(algo::Attr_curs, attr, in_str) {
10490        retval = retval && SeqTrvLenConstOpt_ReadFieldMaybe(parent, attr.name, attr.value);
10491    }ind_end;
10492    return retval;
10493}
10494
10495// --- fasttest.SeqTrvLenConstOpt..Print
10496// print string representation of ROW to string STR
10497// cfmt:fasttest.SeqTrvLenConstOpt.String  printfmt:Tuple
10498void fasttest::SeqTrvLenConstOpt_Print(fasttest::SeqTrvLenConstOpt& row, algo::cstring& str) {
10499    algo::tempstr temp;
10500    str << "fasttest.SeqTrvLenConstOpt";
10501
10502    if (TrvSeqLenConstOpt_PresentQ(row)) {
10503        fasttest::TrvSeqLenConstOpt_Print(row.TrvSeqLenConstOpt, temp);
10504        PrintAttrSpaceReset(str,"TrvSeqLenConstOpt", temp);
10505    }
10506}
10507
10508// --- fasttest.SeqTrvLenConstOpt..FastEncode
10509void fasttest::SeqTrvLenConstOpt_FastEncode(algo::ByteAry& buf, FastState& state, fasttest::SeqTrvLenConstOpt& parent) {
10510    int index = ary_N(buf);
10511    u64 pmap(0);
10512    if (!tid_AssignedQ(state) || parent.id != state.tid) {
10513        lib_fast::EncodeUnsigned(buf,parent.id,false);
10514        lib_fast::SetPmapBit(pmap,0);
10515    }
10516    tid_SetAssigned(state);
10517    state.tid = parent.id;
10518    // TrvSeqLenConstOpt sequence none optional
10519    if (TrvSeqLenConstOpt_PresentQ(parent)) {
10520        TrvSeqLenConstOpt_FastEncode(buf,state,parent.TrvSeqLenConstOpt);
10521        lib_fast::SetPmapBit(pmap,1);
10522    }
10523    lib_fast::InsertPmap(buf,index,pmap);
10524}
10525
10526// --- fasttest.SeqTrvLenConstOpt..FastDecode
10527bool fasttest::SeqTrvLenConstOpt_FastDecode(algo::memptr& from, u64 pmap, FastState& state, fasttest::SeqTrvLenConstOpt& parent) {
10528    bool ok = true;
10529    // TrvSeqLenConstOpt sequence none optional
10530    if (ok) {
10531        bool prs = lib_fast::GetPmapBit(pmap,1);
10532        pmask_qSetBitVal(parent,TrvSeqLenConstOpt_Present_GetBit(parent),prs);
10533        if (prs) {
10534            ok = TrvSeqLenConstOpt_FastDecode(from,state,parent.TrvSeqLenConstOpt);
10535        }
10536    }
10537    return ok;
10538}
10539
10540// --- fasttest.SeqTrvLenConstOpt..FixEncode
10541void fasttest::SeqTrvLenConstOpt_FixEncode(cstring& buf, fasttest::SeqTrvLenConstOpt& parent, char soh) {
10542    buf << "2=1" << soh;
10543    if (TrvSeqLenConstOpt_PresentQ(parent)) {
10544        buf << "1=" << parent.TrvSeqLenConstOpt << soh;
10545    }
10546}
10547
10548// --- fasttest.TrvSeqLenDflt..ReadFieldMaybe
10549bool fasttest::TrvSeqLenDflt_ReadFieldMaybe(fasttest::TrvSeqLenDflt& parent, algo::strptr field, algo::strptr strval) {
10550    bool retval = true;
10551    fasttest::FieldId field_id;
10552    (void)value_SetStrptrMaybe(field_id,field);
10553    switch(field_id) {
10554        case fasttest_FieldId_Value: {
10555            retval = u32_ReadStrptrMaybe(parent.Value, strval);
10556            break;
10557        }
10558        default: break;
10559    }
10560    if (!retval) {
10561        algo_lib::AppendErrtext("attr",field);
10562    }
10563    return retval;
10564}
10565
10566// --- fasttest.TrvSeqLenDflt..ReadStrptrMaybe
10567// Read fields of fasttest::TrvSeqLenDflt from an ascii string.
10568// The format of the string is an ssim Tuple
10569bool fasttest::TrvSeqLenDflt_ReadStrptrMaybe(fasttest::TrvSeqLenDflt &parent, algo::strptr in_str) {
10570    bool retval = true;
10571    retval = algo::StripTypeTag(in_str, "fasttest.TrvSeqLenDflt");
10572    ind_beg(algo::Attr_curs, attr, in_str) {
10573        retval = retval && TrvSeqLenDflt_ReadFieldMaybe(parent, attr.name, attr.value);
10574    }ind_end;
10575    return retval;
10576}
10577
10578// --- fasttest.TrvSeqLenDflt..Print
10579// print string representation of ROW to string STR
10580// cfmt:fasttest.TrvSeqLenDflt.String  printfmt:Tuple
10581void fasttest::TrvSeqLenDflt_Print(fasttest::TrvSeqLenDflt& row, algo::cstring& str) {
10582    algo::tempstr temp;
10583    str << "fasttest.TrvSeqLenDflt";
10584
10585    u32_Print(row.Value, temp);
10586    PrintAttrSpaceReset(str,"Value", temp);
10587}
10588
10589// --- fasttest.TrvSeqLenDflt..FastEncode
10590void fasttest::TrvSeqLenDflt_FastEncode(algo::ByteAry& buf, FastState& state, fasttest::TrvSeqLenDflt& parent) {
10591    // Value unsigned none mandatory
10592    lib_fast::EncodeUnsigned(buf,parent.Value,false);
10593    (void)state;//only to avoid -Wunused-parameter
10594}
10595
10596// --- fasttest.TrvSeqLenDflt..FastDecode
10597bool fasttest::TrvSeqLenDflt_FastDecode(algo::memptr& from, FastState& state, fasttest::TrvSeqLenDflt& parent) {
10598    bool ok = true;
10599    // Value unsigned none mandatory
10600    if (ok) {
10601        ok = lib_fast::DecodeUnsigned(from,parent.Value,false);
10602        if (!ok) {
10603            state.error << "fasttest.TrvSeqLenDflt.Value: bad Unsigned" << eol;
10604        }
10605    }
10606    return ok;
10607}
10608
10609// --- fasttest.TrvSeqLenDflt..FixEncode
10610void fasttest::TrvSeqLenDflt_FixEncode(cstring& buf, fasttest::TrvSeqLenDflt& parent, char soh) {
10611    buf << "3=" << parent.Value << soh;
10612}
10613
10614// --- fasttest.SeqTrvLenDflt.base.CopyOut
10615// Copy fields out of row
10616void fasttest::parent_CopyOut(fasttest::SeqTrvLenDflt &row, fasttest::TemplateHeader &out) {
10617    // length: field value is computed
10618    // id: field value is computed
10619    (void)row;//only to avoid -Wunused-parameter
10620    (void)out;//only to avoid -Wunused-parameter
10621}
10622
10623// --- fasttest.SeqTrvLenDflt.TrvSeqLenDflt.Getary
10624// Access var-length portion as an aryptr. Length is determined from one of the fields.
10625algo::aryptr<fasttest::TrvSeqLenDflt> fasttest::TrvSeqLenDflt_Getary(fasttest::SeqTrvLenDflt& parent) {
10626    return algo::aryptr<fasttest::TrvSeqLenDflt>(TrvSeqLenDflt_Addr(parent), TrvSeqLenDflt_N(parent));
10627}
10628
10629// --- fasttest.SeqTrvLenDflt.TrvSeqLenDflt.Addr
10630fasttest::TrvSeqLenDflt* fasttest::TrvSeqLenDflt_Addr(fasttest::SeqTrvLenDflt& parent) {
10631    return (fasttest::TrvSeqLenDflt*)((u8*)&parent + sizeof(fasttest::SeqTrvLenDflt)); // address of varlen portion
10632}
10633
10634// --- fasttest.SeqTrvLenDflt.TrvSeqLenDflt.ReadStrptrMaybe
10635// Convert string to field. Return success value
10636bool fasttest::TrvSeqLenDflt_ReadStrptrMaybe(fasttest::SeqTrvLenDflt& parent, algo::strptr in_str) {
10637    bool retval = true;
10638    if (algo_lib::_db.varlenbuf) {
10639        fasttest::TrvSeqLenDflt *TrvSeqLenDflt_tmp = new(ary_AllocN(*algo_lib::_db.varlenbuf, sizeof(fasttest::TrvSeqLenDflt)).elems) fasttest::TrvSeqLenDflt;
10640        retval = fasttest::TrvSeqLenDflt_ReadStrptrMaybe(*TrvSeqLenDflt_tmp, in_str);
10641    }
10642    (void)parent;//only to avoid -Wunused-parameter
10643    return retval;
10644}
10645
10646// --- fasttest.SeqTrvLenDflt..ReadFieldMaybe
10647bool fasttest::SeqTrvLenDflt_ReadFieldMaybe(fasttest::SeqTrvLenDflt& parent, algo::strptr field, algo::strptr strval) {
10648    bool retval = true;
10649    fasttest::FieldId field_id;
10650    (void)value_SetStrptrMaybe(field_id,algo::Pathcomp(field, ".LL"));
10651    switch(field_id) {
10652        case fasttest_FieldId_base: {
10653            retval = false;
10654            break;
10655        }
10656        case fasttest_FieldId_length: {
10657            retval = false;
10658            break;
10659        }
10660        case fasttest_FieldId_id: {
10661            retval = false;
10662            break;
10663        }
10664        case fasttest_FieldId_TrvSeqLenDflt: {
10665            retval = TrvSeqLenDflt_ReadStrptrMaybe(parent, strval);
10666            break;
10667        }
10668        default: break;
10669    }
10670    if (!retval) {
10671        algo_lib::AppendErrtext("attr",field);
10672    }
10673    return retval;
10674}
10675
10676// --- fasttest.SeqTrvLenDflt..ReadStrptrMaybe
10677// Any varlen fields are returned in algo_lib::_db.varlenbuf if set
10678// Read fields of fasttest::SeqTrvLenDflt from an ascii string.
10679// The format of the string is an ssim Tuple
10680bool fasttest::SeqTrvLenDflt_ReadStrptrMaybe(fasttest::SeqTrvLenDflt &parent, algo::strptr in_str) {
10681    bool retval = true;
10682    retval = algo::StripTypeTag(in_str, "fasttest.SeqTrvLenDflt");
10683    ind_beg(algo::Attr_curs, attr, in_str) {
10684        retval = retval && SeqTrvLenDflt_ReadFieldMaybe(parent, attr.name, attr.value);
10685    }ind_end;
10686    return retval;
10687}
10688
10689// --- fasttest.SeqTrvLenDflt..Print
10690// print string representation of ROW to string STR
10691// cfmt:fasttest.SeqTrvLenDflt.String  printfmt:Tuple
10692void fasttest::SeqTrvLenDflt_Print(fasttest::SeqTrvLenDflt& row, algo::cstring& str) {
10693    algo::tempstr temp;
10694    str << "fasttest.SeqTrvLenDflt";
10695
10696    ind_beg(SeqTrvLenDflt_TrvSeqLenDflt_curs,TrvSeqLenDflt,row) {
10697        fasttest::TrvSeqLenDflt_Print(TrvSeqLenDflt, temp);
10698        tempstr name;
10699        name << "TrvSeqLenDflt.";
10700        name << ind_curs(TrvSeqLenDflt).index;
10701        PrintAttrSpaceReset(str, name, temp);
10702    }ind_end;
10703}
10704
10705// --- fasttest.SeqTrvLenDflt..FastEncode
10706void fasttest::SeqTrvLenDflt_FastEncode(algo::ByteAry& buf, FastState& state, fasttest::SeqTrvLenDflt& parent) {
10707    int index = ary_N(buf);
10708    u64 pmap(0);
10709    if (!tid_AssignedQ(state) || parent.id != state.tid) {
10710        lib_fast::EncodeUnsigned(buf,parent.id,false);
10711        lib_fast::SetPmapBit(pmap,0);
10712    }
10713    tid_SetAssigned(state);
10714    state.tid = parent.id;
10715    // TrvSeqLenDflt sequence none mandatory
10716    {
10717        u32 length = TrvSeqLenDflt_N(parent);
10718        if (length != 1) {
10719            lib_fast::EncodeUnsigned(buf,length,false);
10720            lib_fast::SetPmapBit(pmap,1);
10721        }
10722        ind_beg(SeqTrvLenDflt_TrvSeqLenDflt_curs,elem,parent) {
10723            TrvSeqLenDflt_FastEncode(buf,state,elem);
10724        }ind_end;
10725    }
10726    lib_fast::InsertPmap(buf,index,pmap);
10727}
10728
10729// --- fasttest.SeqTrvLenDflt..FastDecode
10730bool fasttest::SeqTrvLenDflt_FastDecode(algo::memptr& from, u64 pmap, FastState& state, fasttest::SeqTrvLenDflt& parent) {
10731    bool ok = true;
10732    // TrvSeqLenDflt sequence none mandatory
10733    if (ok) {
10734        u32 length(0);
10735        bool prs = lib_fast::GetPmapBit(pmap,1);
10736        if (prs) {
10737            ok = lib_fast::DecodeUnsigned(from,length,false);
10738            if (!ok) {
10739                state.error << "fasttest.SeqTrvLenDflt.TrvSeqLenDflt: bad Unsigned" << eol;
10740            }
10741        } else {
10742            length = 1;
10743        }
10744        if (!ok) {
10745            state.error << "fasttest.SeqTrvLenDflt.TrvSeqLenDflt: bad length" << eol;
10746        }
10747        for (unsigned i=0; ok && i<length; ++i) {
10748            TrvSeqLenDflt &seq = *new(ary_AllocN(lib_fast::_db.varlen,sizeof seq).elems) TrvSeqLenDflt;
10749            ok = TrvSeqLenDflt_FastDecode(from,state,seq);
10750            if (!ok) {
10751                state.error << "fasttest.SeqTrvLenDflt.TrvSeqLenDflt: element #"<< i+1 << eol;
10752            }
10753        }
10754    }
10755    (void)parent;//only to avoid -Wunused-parameter
10756    return ok;
10757}
10758
10759// --- fasttest.SeqTrvLenDflt..FixEncode
10760void fasttest::SeqTrvLenDflt_FixEncode(cstring& buf, fasttest::SeqTrvLenDflt& parent, char soh) {
10761    {
10762        u32 length = TrvSeqLenDflt_N(parent);
10763        if (length) {
10764            buf << "2=" << length << soh;
10765        }
10766    }
10767    ind_beg(SeqTrvLenDflt_TrvSeqLenDflt_curs,elem,parent) {
10768        TrvSeqLenDflt_FixEncode(buf,elem,soh);
10769    }ind_end;
10770}
10771
10772// --- fasttest.TrvSeqDfltOpt..ReadFieldMaybe
10773bool fasttest::TrvSeqDfltOpt_ReadFieldMaybe(fasttest::TrvSeqDfltOpt& parent, algo::strptr field, algo::strptr strval) {
10774    bool retval = true;
10775    fasttest::FieldId field_id;
10776    (void)value_SetStrptrMaybe(field_id,field);
10777    switch(field_id) {
10778        case fasttest_FieldId_Value: {
10779            retval = u32_ReadStrptrMaybe(parent.Value, strval);
10780            break;
10781        }
10782        default: break;
10783    }
10784    if (!retval) {
10785        algo_lib::AppendErrtext("attr",field);
10786    }
10787    return retval;
10788}
10789
10790// --- fasttest.TrvSeqDfltOpt..ReadStrptrMaybe
10791// Read fields of fasttest::TrvSeqDfltOpt from an ascii string.
10792// The format of the string is an ssim Tuple
10793bool fasttest::TrvSeqDfltOpt_ReadStrptrMaybe(fasttest::TrvSeqDfltOpt &parent, algo::strptr in_str) {
10794    bool retval = true;
10795    retval = algo::StripTypeTag(in_str, "fasttest.TrvSeqDfltOpt");
10796    ind_beg(algo::Attr_curs, attr, in_str) {
10797        retval = retval && TrvSeqDfltOpt_ReadFieldMaybe(parent, attr.name, attr.value);
10798    }ind_end;
10799    return retval;
10800}
10801
10802// --- fasttest.TrvSeqDfltOpt..Print
10803// print string representation of ROW to string STR
10804// cfmt:fasttest.TrvSeqDfltOpt.String  printfmt:Tuple
10805void fasttest::TrvSeqDfltOpt_Print(fasttest::TrvSeqDfltOpt& row, algo::cstring& str) {
10806    algo::tempstr temp;
10807    str << "fasttest.TrvSeqDfltOpt";
10808
10809    u32_Print(row.Value, temp);
10810    PrintAttrSpaceReset(str,"Value", temp);
10811}
10812
10813// --- fasttest.TrvSeqDfltOpt..FastEncode
10814void fasttest::TrvSeqDfltOpt_FastEncode(algo::ByteAry& buf, FastState& state, fasttest::TrvSeqDfltOpt& parent) {
10815    // Value unsigned none mandatory
10816    lib_fast::EncodeUnsigned(buf,parent.Value,false);
10817    (void)state;//only to avoid -Wunused-parameter
10818}
10819
10820// --- fasttest.TrvSeqDfltOpt..FastDecode
10821bool fasttest::TrvSeqDfltOpt_FastDecode(algo::memptr& from, FastState& state, fasttest::TrvSeqDfltOpt& parent) {
10822    bool ok = true;
10823    // Value unsigned none mandatory
10824    if (ok) {
10825        ok = lib_fast::DecodeUnsigned(from,parent.Value,false);
10826        if (!ok) {
10827            state.error << "fasttest.TrvSeqDfltOpt.Value: bad Unsigned" << eol;
10828        }
10829    }
10830    return ok;
10831}
10832
10833// --- fasttest.TrvSeqDfltOpt..FixEncode
10834void fasttest::TrvSeqDfltOpt_FixEncode(cstring& buf, fasttest::TrvSeqDfltOpt& parent, char soh) {
10835    buf << "3=" << parent.Value << soh;
10836}
10837
10838// --- fasttest.SeqTrvLenDfltOpt.base.CopyOut
10839// Copy fields out of row
10840void fasttest::parent_CopyOut(fasttest::SeqTrvLenDfltOpt &row, fasttest::TemplateHeader &out) {
10841    // length: field value is computed
10842    // id: field value is computed
10843    (void)row;//only to avoid -Wunused-parameter
10844    (void)out;//only to avoid -Wunused-parameter
10845}
10846
10847// --- fasttest.SeqTrvLenDfltOpt.TrvSeqDfltOpt.Getary
10848// Access var-length portion as an aryptr. Length is determined from one of the fields.
10849algo::aryptr<fasttest::TrvSeqDfltOpt> fasttest::TrvSeqDfltOpt_Getary(fasttest::SeqTrvLenDfltOpt& parent) {
10850    return algo::aryptr<fasttest::TrvSeqDfltOpt>(TrvSeqDfltOpt_Addr(parent), TrvSeqDfltOpt_N(parent));
10851}
10852
10853// --- fasttest.SeqTrvLenDfltOpt.TrvSeqDfltOpt.Addr
10854fasttest::TrvSeqDfltOpt* fasttest::TrvSeqDfltOpt_Addr(fasttest::SeqTrvLenDfltOpt& parent) {
10855    return (fasttest::TrvSeqDfltOpt*)((u8*)&parent + sizeof(fasttest::SeqTrvLenDfltOpt)); // address of varlen portion
10856}
10857
10858// --- fasttest.SeqTrvLenDfltOpt.TrvSeqDfltOpt.ReadStrptrMaybe
10859// Convert string to field. Return success value
10860bool fasttest::TrvSeqDfltOpt_ReadStrptrMaybe(fasttest::SeqTrvLenDfltOpt& parent, algo::strptr in_str) {
10861    bool retval = true;
10862    if (algo_lib::_db.varlenbuf) {
10863        fasttest::TrvSeqDfltOpt *TrvSeqDfltOpt_tmp = new(ary_AllocN(*algo_lib::_db.varlenbuf, sizeof(fasttest::TrvSeqDfltOpt)).elems) fasttest::TrvSeqDfltOpt;
10864        retval = fasttest::TrvSeqDfltOpt_ReadStrptrMaybe(*TrvSeqDfltOpt_tmp, in_str);
10865    }
10866    (void)parent;//only to avoid -Wunused-parameter
10867    return retval;
10868}
10869
10870// --- fasttest.SeqTrvLenDfltOpt..ReadFieldMaybe
10871bool fasttest::SeqTrvLenDfltOpt_ReadFieldMaybe(fasttest::SeqTrvLenDfltOpt& parent, algo::strptr field, algo::strptr strval) {
10872    bool retval = true;
10873    fasttest::FieldId field_id;
10874    (void)value_SetStrptrMaybe(field_id,algo::Pathcomp(field, ".LL"));
10875    switch(field_id) {
10876        case fasttest_FieldId_base: {
10877            retval = false;
10878            break;
10879        }
10880        case fasttest_FieldId_length: {
10881            retval = false;
10882            break;
10883        }
10884        case fasttest_FieldId_id: {
10885            retval = false;
10886            break;
10887        }
10888        case fasttest_FieldId_TrvSeqDfltOpt: {
10889            retval = TrvSeqDfltOpt_ReadStrptrMaybe(parent, strval);
10890            break;
10891        }
10892        default: break;
10893    }
10894    if (!retval) {
10895        algo_lib::AppendErrtext("attr",field);
10896    }
10897    return retval;
10898}
10899
10900// --- fasttest.SeqTrvLenDfltOpt..ReadStrptrMaybe
10901// Any varlen fields are returned in algo_lib::_db.varlenbuf if set
10902// Read fields of fasttest::SeqTrvLenDfltOpt from an ascii string.
10903// The format of the string is an ssim Tuple
10904bool fasttest::SeqTrvLenDfltOpt_ReadStrptrMaybe(fasttest::SeqTrvLenDfltOpt &parent, algo::strptr in_str) {
10905    bool retval = true;
10906    retval = algo::StripTypeTag(in_str, "fasttest.SeqTrvLenDfltOpt");
10907    ind_beg(algo::Attr_curs, attr, in_str) {
10908        retval = retval && SeqTrvLenDfltOpt_ReadFieldMaybe(parent, attr.name, attr.value);
10909    }ind_end;
10910    return retval;
10911}
10912
10913// --- fasttest.SeqTrvLenDfltOpt..Print
10914// print string representation of ROW to string STR
10915// cfmt:fasttest.SeqTrvLenDfltOpt.String  printfmt:Tuple
10916void fasttest::SeqTrvLenDfltOpt_Print(fasttest::SeqTrvLenDfltOpt& row, algo::cstring& str) {
10917    algo::tempstr temp;
10918    str << "fasttest.SeqTrvLenDfltOpt";
10919
10920    ind_beg(SeqTrvLenDfltOpt_TrvSeqDfltOpt_curs,TrvSeqDfltOpt,row) {
10921        fasttest::TrvSeqDfltOpt_Print(TrvSeqDfltOpt, temp);
10922        tempstr name;
10923        name << "TrvSeqDfltOpt.";
10924        name << ind_curs(TrvSeqDfltOpt).index;
10925        PrintAttrSpaceReset(str, name, temp);
10926    }ind_end;
10927}
10928
10929// --- fasttest.SeqTrvLenDfltOpt..FastEncode
10930void fasttest::SeqTrvLenDfltOpt_FastEncode(algo::ByteAry& buf, FastState& state, fasttest::SeqTrvLenDfltOpt& parent) {
10931    int index = ary_N(buf);
10932    u64 pmap(0);
10933    if (!tid_AssignedQ(state) || parent.id != state.tid) {
10934        lib_fast::EncodeUnsigned(buf,parent.id,false);
10935        lib_fast::SetPmapBit(pmap,0);
10936    }
10937    tid_SetAssigned(state);
10938    state.tid = parent.id;
10939    // TrvSeqDfltOpt sequence none optional
10940    {
10941        u32 length = TrvSeqDfltOpt_N(parent);
10942        if (length) {
10943            if (length != 1) {
10944                lib_fast::EncodeUnsigned(buf,length,true);
10945                lib_fast::SetPmapBit(pmap,1);
10946            }
10947        } else {
10948            lib_fast::EncodeNull(buf);
10949            lib_fast::SetPmapBit(pmap,1);
10950        }
10951        ind_beg(SeqTrvLenDfltOpt_TrvSeqDfltOpt_curs,elem,parent) {
10952            TrvSeqDfltOpt_FastEncode(buf,state,elem);
10953        }ind_end;
10954    }
10955    lib_fast::InsertPmap(buf,index,pmap);
10956}
10957
10958// --- fasttest.SeqTrvLenDfltOpt..FastDecode
10959bool fasttest::SeqTrvLenDfltOpt_FastDecode(algo::memptr& from, u64 pmap, FastState& state, fasttest::SeqTrvLenDfltOpt& parent) {
10960    bool ok = true;
10961    // TrvSeqDfltOpt sequence none optional
10962    if (ok) {
10963        u32 length(0);
10964        bool prs = lib_fast::GetPmapBit(pmap,1);
10965        if (prs) {
10966            prs = !lib_fast::DecodeNull(from);
10967            if (prs) {
10968                ok = lib_fast::DecodeUnsigned(from,length,true);
10969                if (!ok) {
10970                    state.error << "fasttest.SeqTrvLenDfltOpt.TrvSeqDfltOpt: bad Unsigned" << eol;
10971                }
10972            }
10973        } else {
10974            length = 1;
10975            prs = true;
10976        }
10977        ;
10978        if (!ok) {
10979            state.error << "fasttest.SeqTrvLenDfltOpt.TrvSeqDfltOpt: bad length" << eol;
10980        }
10981        length = prs ? length : 0;
10982        for (unsigned i=0; ok && i<length; ++i) {
10983            TrvSeqDfltOpt &seq = *new(ary_AllocN(lib_fast::_db.varlen,sizeof seq).elems) TrvSeqDfltOpt;
10984            ok = TrvSeqDfltOpt_FastDecode(from,state,seq);
10985            if (!ok) {
10986                state.error << "fasttest.SeqTrvLenDfltOpt.TrvSeqDfltOpt: element #"<< i+1 << eol;
10987            }
10988        }
10989    }
10990    (void)parent;//only to avoid -Wunused-parameter
10991    return ok;
10992}
10993
10994// --- fasttest.SeqTrvLenDfltOpt..FixEncode
10995void fasttest::SeqTrvLenDfltOpt_FixEncode(cstring& buf, fasttest::SeqTrvLenDfltOpt& parent, char soh) {
10996    {
10997        u32 length = TrvSeqDfltOpt_N(parent);
10998        if (length) {
10999            buf << "2=" << length << soh;
11000        }
11001    }
11002    ind_beg(SeqTrvLenDfltOpt_TrvSeqDfltOpt_curs,elem,parent) {
11003        TrvSeqDfltOpt_FixEncode(buf,elem,soh);
11004    }ind_end;
11005}
11006
11007// --- fasttest.TrvSeqLenNone..ReadFieldMaybe
11008bool fasttest::TrvSeqLenNone_ReadFieldMaybe(fasttest::TrvSeqLenNone& parent, algo::strptr field, algo::strptr strval) {
11009    bool retval = true;
11010    fasttest::FieldId field_id;
11011    (void)value_SetStrptrMaybe(field_id,field);
11012    switch(field_id) {
11013        case fasttest_FieldId_Value: {
11014            retval = u32_ReadStrptrMaybe(parent.Value, strval);
11015            break;
11016        }
11017        default: break;
11018    }
11019    if (!retval) {
11020        algo_lib::AppendErrtext("attr",field);
11021    }
11022    return retval;
11023}
11024
11025// --- fasttest.TrvSeqLenNone..ReadStrptrMaybe
11026// Read fields of fasttest::TrvSeqLenNone from an ascii string.
11027// The format of the string is an ssim Tuple
11028bool fasttest::TrvSeqLenNone_ReadStrptrMaybe(fasttest::TrvSeqLenNone &parent, algo::strptr in_str) {
11029    bool retval = true;
11030    retval = algo::StripTypeTag(in_str, "fasttest.TrvSeqLenNone");
11031    ind_beg(algo::Attr_curs, attr, in_str) {
11032        retval = retval && TrvSeqLenNone_ReadFieldMaybe(parent, attr.name, attr.value);
11033    }ind_end;
11034    return retval;
11035}
11036
11037// --- fasttest.TrvSeqLenNone..Print
11038// print string representation of ROW to string STR
11039// cfmt:fasttest.TrvSeqLenNone.String  printfmt:Tuple
11040void fasttest::TrvSeqLenNone_Print(fasttest::TrvSeqLenNone& row, algo::cstring& str) {
11041    algo::tempstr temp;
11042    str << "fasttest.TrvSeqLenNone";
11043
11044    u32_Print(row.Value, temp);
11045    PrintAttrSpaceReset(str,"Value", temp);
11046}
11047
11048// --- fasttest.TrvSeqLenNone..FastEncode
11049void fasttest::TrvSeqLenNone_FastEncode(algo::ByteAry& buf, FastState& state, fasttest::TrvSeqLenNone& parent) {
11050    // Value unsigned none mandatory
11051    lib_fast::EncodeUnsigned(buf,parent.Value,false);
11052    (void)state;//only to avoid -Wunused-parameter
11053}
11054
11055// --- fasttest.TrvSeqLenNone..FastDecode
11056bool fasttest::TrvSeqLenNone_FastDecode(algo::memptr& from, FastState& state, fasttest::TrvSeqLenNone& parent) {
11057    bool ok = true;
11058    // Value unsigned none mandatory
11059    if (ok) {
11060        ok = lib_fast::DecodeUnsigned(from,parent.Value,false);
11061        if (!ok) {
11062            state.error << "fasttest.TrvSeqLenNone.Value: bad Unsigned" << eol;
11063        }
11064    }
11065    return ok;
11066}
11067
11068// --- fasttest.TrvSeqLenNone..FixEncode
11069void fasttest::TrvSeqLenNone_FixEncode(cstring& buf, fasttest::TrvSeqLenNone& parent, char soh) {
11070    buf << "3=" << parent.Value << soh;
11071}
11072
11073// --- fasttest.SeqTrvLenNone.base.CopyOut
11074// Copy fields out of row
11075void fasttest::parent_CopyOut(fasttest::SeqTrvLenNone &row, fasttest::TemplateHeader &out) {
11076    // length: field value is computed
11077    // id: field value is computed
11078    (void)row;//only to avoid -Wunused-parameter
11079    (void)out;//only to avoid -Wunused-parameter
11080}
11081
11082// --- fasttest.SeqTrvLenNone.TrvSeqLenNone.Getary
11083// Access var-length portion as an aryptr. Length is determined from one of the fields.
11084algo::aryptr<fasttest::TrvSeqLenNone> fasttest::TrvSeqLenNone_Getary(fasttest::SeqTrvLenNone& parent) {
11085    return algo::aryptr<fasttest::TrvSeqLenNone>(TrvSeqLenNone_Addr(parent), TrvSeqLenNone_N(parent));
11086}
11087
11088// --- fasttest.SeqTrvLenNone.TrvSeqLenNone.Addr
11089fasttest::TrvSeqLenNone* fasttest::TrvSeqLenNone_Addr(fasttest::SeqTrvLenNone& parent) {
11090    return (fasttest::TrvSeqLenNone*)((u8*)&parent + sizeof(fasttest::SeqTrvLenNone)); // address of varlen portion
11091}
11092
11093// --- fasttest.SeqTrvLenNone.TrvSeqLenNone.ReadStrptrMaybe
11094// Convert string to field. Return success value
11095bool fasttest::TrvSeqLenNone_ReadStrptrMaybe(fasttest::SeqTrvLenNone& parent, algo::strptr in_str) {
11096    bool retval = true;
11097    if (algo_lib::_db.varlenbuf) {
11098        fasttest::TrvSeqLenNone *TrvSeqLenNone_tmp = new(ary_AllocN(*algo_lib::_db.varlenbuf, sizeof(fasttest::TrvSeqLenNone)).elems) fasttest::TrvSeqLenNone;
11099        retval = fasttest::TrvSeqLenNone_ReadStrptrMaybe(*TrvSeqLenNone_tmp, in_str);
11100    }
11101    (void)parent;//only to avoid -Wunused-parameter
11102    return retval;
11103}
11104
11105// --- fasttest.SeqTrvLenNone..ReadFieldMaybe
11106bool fasttest::SeqTrvLenNone_ReadFieldMaybe(fasttest::SeqTrvLenNone& parent, algo::strptr field, algo::strptr strval) {
11107    bool retval = true;
11108    fasttest::FieldId field_id;
11109    (void)value_SetStrptrMaybe(field_id,algo::Pathcomp(field, ".LL"));
11110    switch(field_id) {
11111        case fasttest_FieldId_base: {
11112            retval = false;
11113            break;
11114        }
11115        case fasttest_FieldId_length: {
11116            retval = false;
11117            break;
11118        }
11119        case fasttest_FieldId_id: {
11120            retval = false;
11121            break;
11122        }
11123        case fasttest_FieldId_TrvSeqLenNone: {
11124            retval = TrvSeqLenNone_ReadStrptrMaybe(parent, strval);
11125            break;
11126        }
11127        default: break;
11128    }
11129    if (!retval) {
11130        algo_lib::AppendErrtext("attr",field);
11131    }
11132    return retval;
11133}
11134
11135// --- fasttest.SeqTrvLenNone..ReadStrptrMaybe
11136// Any varlen fields are returned in algo_lib::_db.varlenbuf if set
11137// Read fields of fasttest::SeqTrvLenNone from an ascii string.
11138// The format of the string is an ssim Tuple
11139bool fasttest::SeqTrvLenNone_ReadStrptrMaybe(fasttest::SeqTrvLenNone &parent, algo::strptr in_str) {
11140    bool retval = true;
11141    retval = algo::StripTypeTag(in_str, "fasttest.SeqTrvLenNone");
11142    ind_beg(algo::Attr_curs, attr, in_str) {
11143        retval = retval && SeqTrvLenNone_ReadFieldMaybe(parent, attr.name, attr.value);
11144    }ind_end;
11145    return retval;
11146}
11147
11148// --- fasttest.SeqTrvLenNone..Print
11149// print string representation of ROW to string STR
11150// cfmt:fasttest.SeqTrvLenNone.String  printfmt:Tuple
11151void fasttest::SeqTrvLenNone_Print(fasttest::SeqTrvLenNone& row, algo::cstring& str) {
11152    algo::tempstr temp;
11153    str << "fasttest.SeqTrvLenNone";
11154
11155    ind_beg(SeqTrvLenNone_TrvSeqLenNone_curs,TrvSeqLenNone,row) {
11156        fasttest::TrvSeqLenNone_Print(TrvSeqLenNone, temp);
11157        tempstr name;
11158        name << "TrvSeqLenNone.";
11159        name << ind_curs(TrvSeqLenNone).index;
11160        PrintAttrSpaceReset(str, name, temp);
11161    }ind_end;
11162}
11163
11164// --- fasttest.SeqTrvLenNone..FastEncode
11165void fasttest::SeqTrvLenNone_FastEncode(algo::ByteAry& buf, FastState& state, fasttest::SeqTrvLenNone& parent) {
11166    int index = ary_N(buf);
11167    u64 pmap(0);
11168    if (!tid_AssignedQ(state) || parent.id != state.tid) {
11169        lib_fast::EncodeUnsigned(buf,parent.id,false);
11170        lib_fast::SetPmapBit(pmap,0);
11171    }
11172    tid_SetAssigned(state);
11173    state.tid = parent.id;
11174    // TrvSeqLenNone sequence none mandatory
11175    {
11176        u32 length = TrvSeqLenNone_N(parent);
11177        lib_fast::EncodeUnsigned(buf,length,false);
11178        ind_beg(SeqTrvLenNone_TrvSeqLenNone_curs,elem,parent) {
11179            TrvSeqLenNone_FastEncode(buf,state,elem);
11180        }ind_end;
11181    }
11182    lib_fast::InsertPmap(buf,index,pmap);
11183}
11184
11185// --- fasttest.SeqTrvLenNone..FastDecode
11186bool fasttest::SeqTrvLenNone_FastDecode(algo::memptr& from, u64 pmap, FastState& state, fasttest::SeqTrvLenNone& parent) {
11187    bool ok = true;
11188    // TrvSeqLenNone sequence none mandatory
11189    if (ok) {
11190        u32 length(0);
11191        ok = lib_fast::DecodeUnsigned(from,length,false);
11192        if (!ok) {
11193            state.error << "fasttest.SeqTrvLenNone.TrvSeqLenNone: bad Unsigned" << eol;
11194        }
11195        if (!ok) {
11196            state.error << "fasttest.SeqTrvLenNone.TrvSeqLenNone: bad length" << eol;
11197        }
11198        for (unsigned i=0; ok && i<length; ++i) {
11199            TrvSeqLenNone &seq = *new(ary_AllocN(lib_fast::_db.varlen,sizeof seq).elems) TrvSeqLenNone;
11200            ok = TrvSeqLenNone_FastDecode(from,state,seq);
11201            if (!ok) {
11202                state.error << "fasttest.SeqTrvLenNone.TrvSeqLenNone: element #"<< i+1 << eol;
11203            }
11204        }
11205    }
11206    (void)pmap;//only to avoid -Wunused-parameter
11207    (void)parent;//only to avoid -Wunused-parameter
11208    return ok;
11209}
11210
11211// --- fasttest.SeqTrvLenNone..FixEncode
11212void fasttest::SeqTrvLenNone_FixEncode(cstring& buf, fasttest::SeqTrvLenNone& parent, char soh) {
11213    {
11214        u32 length = TrvSeqLenNone_N(parent);
11215        if (length) {
11216            buf << "2=" << length << soh;
11217        }
11218    }
11219    ind_beg(SeqTrvLenNone_TrvSeqLenNone_curs,elem,parent) {
11220        TrvSeqLenNone_FixEncode(buf,elem,soh);
11221    }ind_end;
11222}
11223
11224// --- fasttest.TrvSeqLenNoneOpt..ReadFieldMaybe
11225bool fasttest::TrvSeqLenNoneOpt_ReadFieldMaybe(fasttest::TrvSeqLenNoneOpt& parent, algo::strptr field, algo::strptr strval) {
11226    bool retval = true;
11227    fasttest::FieldId field_id;
11228    (void)value_SetStrptrMaybe(field_id,field);
11229    switch(field_id) {
11230        case fasttest_FieldId_Value: {
11231            retval = u32_ReadStrptrMaybe(parent.Value, strval);
11232            break;
11233        }
11234        default: break;
11235    }
11236    if (!retval) {
11237        algo_lib::AppendErrtext("attr",field);
11238    }
11239    return retval;
11240}
11241
11242// --- fasttest.TrvSeqLenNoneOpt..ReadStrptrMaybe
11243// Read fields of fasttest::TrvSeqLenNoneOpt from an ascii string.
11244// The format of the string is an ssim Tuple
11245bool fasttest::TrvSeqLenNoneOpt_ReadStrptrMaybe(fasttest::TrvSeqLenNoneOpt &parent, algo::strptr in_str) {
11246    bool retval = true;
11247    retval = algo::StripTypeTag(in_str, "fasttest.TrvSeqLenNoneOpt");
11248    ind_beg(algo::Attr_curs, attr, in_str) {
11249        retval = retval && TrvSeqLenNoneOpt_ReadFieldMaybe(parent, attr.name, attr.value);
11250    }ind_end;
11251    return retval;
11252}
11253
11254// --- fasttest.TrvSeqLenNoneOpt..Print
11255// print string representation of ROW to string STR
11256// cfmt:fasttest.TrvSeqLenNoneOpt.String  printfmt:Tuple
11257void fasttest::TrvSeqLenNoneOpt_Print(fasttest::TrvSeqLenNoneOpt& row, algo::cstring& str) {
11258    algo::tempstr temp;
11259    str << "fasttest.TrvSeqLenNoneOpt";
11260
11261    u32_Print(row.Value, temp);
11262    PrintAttrSpaceReset(str,"Value", temp);
11263}
11264
11265// --- fasttest.TrvSeqLenNoneOpt..FastEncode
11266void fasttest::TrvSeqLenNoneOpt_FastEncode(algo::ByteAry& buf, FastState& state, fasttest::TrvSeqLenNoneOpt& parent) {
11267    // Value unsigned none mandatory
11268    lib_fast::EncodeUnsigned(buf,parent.Value,false);
11269    (void)state;//only to avoid -Wunused-parameter
11270}
11271
11272// --- fasttest.TrvSeqLenNoneOpt..FastDecode
11273bool fasttest::TrvSeqLenNoneOpt_FastDecode(algo::memptr& from, FastState& state, fasttest::TrvSeqLenNoneOpt& parent) {
11274    bool ok = true;
11275    // Value unsigned none mandatory
11276    if (ok) {
11277        ok = lib_fast::DecodeUnsigned(from,parent.Value,false);
11278        if (!ok) {
11279            state.error << "fasttest.TrvSeqLenNoneOpt.Value: bad Unsigned" << eol;
11280        }
11281    }
11282    return ok;
11283}
11284
11285// --- fasttest.TrvSeqLenNoneOpt..FixEncode
11286void fasttest::TrvSeqLenNoneOpt_FixEncode(cstring& buf, fasttest::TrvSeqLenNoneOpt& parent, char soh) {
11287    buf << "3=" << parent.Value << soh;
11288}
11289
11290// --- fasttest.SeqTrvLenNoneOpt.base.CopyOut
11291// Copy fields out of row
11292void fasttest::parent_CopyOut(fasttest::SeqTrvLenNoneOpt &row, fasttest::TemplateHeader &out) {
11293    // length: field value is computed
11294    // id: field value is computed
11295    (void)row;//only to avoid -Wunused-parameter
11296    (void)out;//only to avoid -Wunused-parameter
11297}
11298
11299// --- fasttest.SeqTrvLenNoneOpt.TrvSeqLenNoneOpt.Getary
11300// Access var-length portion as an aryptr. Length is determined from one of the fields.
11301algo::aryptr<fasttest::TrvSeqLenNoneOpt> fasttest::TrvSeqLenNoneOpt_Getary(fasttest::SeqTrvLenNoneOpt& parent) {
11302    return algo::aryptr<fasttest::TrvSeqLenNoneOpt>(TrvSeqLenNoneOpt_Addr(parent), TrvSeqLenNoneOpt_N(parent));
11303}
11304
11305// --- fasttest.SeqTrvLenNoneOpt.TrvSeqLenNoneOpt.Addr
11306fasttest::TrvSeqLenNoneOpt* fasttest::TrvSeqLenNoneOpt_Addr(fasttest::SeqTrvLenNoneOpt& parent) {
11307    return (fasttest::TrvSeqLenNoneOpt*)((u8*)&parent + sizeof(fasttest::SeqTrvLenNoneOpt)); // address of varlen portion
11308}
11309
11310// --- fasttest.SeqTrvLenNoneOpt.TrvSeqLenNoneOpt.ReadStrptrMaybe
11311// Convert string to field. Return success value
11312bool fasttest::TrvSeqLenNoneOpt_ReadStrptrMaybe(fasttest::SeqTrvLenNoneOpt& parent, algo::strptr in_str) {
11313    bool retval = true;
11314    if (algo_lib::_db.varlenbuf) {
11315        fasttest::TrvSeqLenNoneOpt *TrvSeqLenNoneOpt_tmp = new(ary_AllocN(*algo_lib::_db.varlenbuf, sizeof(fasttest::TrvSeqLenNoneOpt)).elems) fasttest::TrvSeqLenNoneOpt;
11316        retval = fasttest::TrvSeqLenNoneOpt_ReadStrptrMaybe(*TrvSeqLenNoneOpt_tmp, in_str);
11317    }
11318    (void)parent;//only to avoid -Wunused-parameter
11319    return retval;
11320}
11321
11322// --- fasttest.SeqTrvLenNoneOpt..ReadFieldMaybe
11323bool fasttest::SeqTrvLenNoneOpt_ReadFieldMaybe(fasttest::SeqTrvLenNoneOpt& parent, algo::strptr field, algo::strptr strval) {
11324    bool retval = true;
11325    fasttest::FieldId field_id;
11326    (void)value_SetStrptrMaybe(field_id,algo::Pathcomp(field, ".LL"));
11327    switch(field_id) {
11328        case fasttest_FieldId_base: {
11329            retval = false;
11330            break;
11331        }
11332        case fasttest_FieldId_length: {
11333            retval = false;
11334            break;
11335        }
11336        case fasttest_FieldId_id: {
11337            retval = false;
11338            break;
11339        }
11340        case fasttest_FieldId_TrvSeqLenNoneOpt: {
11341            retval = TrvSeqLenNoneOpt_ReadStrptrMaybe(parent, strval);
11342            break;
11343        }
11344        default: break;
11345    }
11346    if (!retval) {
11347        algo_lib::AppendErrtext("attr",field);
11348    }
11349    return retval;
11350}
11351
11352// --- fasttest.SeqTrvLenNoneOpt..ReadStrptrMaybe
11353// Any varlen fields are returned in algo_lib::_db.varlenbuf if set
11354// Read fields of fasttest::SeqTrvLenNoneOpt from an ascii string.
11355// The format of the string is an ssim Tuple
11356bool fasttest::SeqTrvLenNoneOpt_ReadStrptrMaybe(fasttest::SeqTrvLenNoneOpt &parent, algo::strptr in_str) {
11357    bool retval = true;
11358    retval = algo::StripTypeTag(in_str, "fasttest.SeqTrvLenNoneOpt");
11359    ind_beg(algo::Attr_curs, attr, in_str) {
11360        retval = retval && SeqTrvLenNoneOpt_ReadFieldMaybe(parent, attr.name, attr.value);
11361    }ind_end;
11362    return retval;
11363}
11364
11365// --- fasttest.SeqTrvLenNoneOpt..Print
11366// print string representation of ROW to string STR
11367// cfmt:fasttest.SeqTrvLenNoneOpt.String  printfmt:Tuple
11368void fasttest::SeqTrvLenNoneOpt_Print(fasttest::SeqTrvLenNoneOpt& row, algo::cstring& str) {
11369    algo::tempstr temp;
11370    str << "fasttest.SeqTrvLenNoneOpt";
11371
11372    ind_beg(SeqTrvLenNoneOpt_TrvSeqLenNoneOpt_curs,TrvSeqLenNoneOpt,row) {
11373        fasttest::TrvSeqLenNoneOpt_Print(TrvSeqLenNoneOpt, temp);
11374        tempstr name;
11375        name << "TrvSeqLenNoneOpt.";
11376        name << ind_curs(TrvSeqLenNoneOpt).index;
11377        PrintAttrSpaceReset(str, name, temp);
11378    }ind_end;
11379}
11380
11381// --- fasttest.SeqTrvLenNoneOpt..FastEncode
11382void fasttest::SeqTrvLenNoneOpt_FastEncode(algo::ByteAry& buf, FastState& state, fasttest::SeqTrvLenNoneOpt& parent) {
11383    int index = ary_N(buf);
11384    u64 pmap(0);
11385    if (!tid_AssignedQ(state) || parent.id != state.tid) {
11386        lib_fast::EncodeUnsigned(buf,parent.id,false);
11387        lib_fast::SetPmapBit(pmap,0);
11388    }
11389    tid_SetAssigned(state);
11390    state.tid = parent.id;
11391    // TrvSeqLenNoneOpt sequence none optional
11392    {
11393        u32 length = TrvSeqLenNoneOpt_N(parent);
11394        if (length) {
11395            lib_fast::EncodeUnsigned(buf,length,true);
11396        } else {
11397            lib_fast::EncodeNull(buf);
11398        }
11399        ind_beg(SeqTrvLenNoneOpt_TrvSeqLenNoneOpt_curs,elem,parent) {
11400            TrvSeqLenNoneOpt_FastEncode(buf,state,elem);
11401        }ind_end;
11402    }
11403    lib_fast::InsertPmap(buf,index,pmap);
11404}
11405
11406// --- fasttest.SeqTrvLenNoneOpt..FastDecode
11407bool fasttest::SeqTrvLenNoneOpt_FastDecode(algo::memptr& from, u64 pmap, FastState& state, fasttest::SeqTrvLenNoneOpt& parent) {
11408    bool ok = true;
11409    // TrvSeqLenNoneOpt sequence none optional
11410    if (ok) {
11411        u32 length(0);
11412        bool prs = !lib_fast::DecodeNull(from);
11413        if (prs) {
11414            ok = lib_fast::DecodeUnsigned(from,length,true);
11415            if (!ok) {
11416                state.error << "fasttest.SeqTrvLenNoneOpt.TrvSeqLenNoneOpt: bad Unsigned" << eol;
11417            }
11418        }
11419        ;
11420        if (!ok) {
11421            state.error << "fasttest.SeqTrvLenNoneOpt.TrvSeqLenNoneOpt: bad length" << eol;
11422        }
11423        length = prs ? length : 0;
11424        for (unsigned i=0; ok && i<length; ++i) {
11425            TrvSeqLenNoneOpt &seq = *new(ary_AllocN(lib_fast::_db.varlen,sizeof seq).elems) TrvSeqLenNoneOpt;
11426            ok = TrvSeqLenNoneOpt_FastDecode(from,state,seq);
11427            if (!ok) {
11428                state.error << "fasttest.SeqTrvLenNoneOpt.TrvSeqLenNoneOpt: element #"<< i+1 << eol;
11429            }
11430        }
11431    }
11432    (void)pmap;//only to avoid -Wunused-parameter
11433    (void)parent;//only to avoid -Wunused-parameter
11434    return ok;
11435}
11436
11437// --- fasttest.SeqTrvLenNoneOpt..FixEncode
11438void fasttest::SeqTrvLenNoneOpt_FixEncode(cstring& buf, fasttest::SeqTrvLenNoneOpt& parent, char soh) {
11439    {
11440        u32 length = TrvSeqLenNoneOpt_N(parent);
11441        if (length) {
11442            buf << "2=" << length << soh;
11443        }
11444    }
11445    ind_beg(SeqTrvLenNoneOpt_TrvSeqLenNoneOpt_curs,elem,parent) {
11446        TrvSeqLenNoneOpt_FixEncode(buf,elem,soh);
11447    }ind_end;
11448}
11449
11450// --- fasttest.SeqTrvOpt.base.CopyOut
11451// Copy fields out of row
11452void fasttest::parent_CopyOut(fasttest::SeqTrvOpt &row, fasttest::TemplateHeader &out) {
11453    // length: field value is computed
11454    // id: field value is computed
11455    (void)row;//only to avoid -Wunused-parameter
11456    (void)out;//only to avoid -Wunused-parameter
11457}
11458
11459// --- fasttest.SeqTrvOpt.OptTrvSeq.Getary
11460// Access var-length portion as an aryptr. Length is determined from one of the fields.
11461algo::aryptr<fasttest::OptTrvSeq> fasttest::OptTrvSeq_Getary(fasttest::SeqTrvOpt& parent) {
11462    return algo::aryptr<fasttest::OptTrvSeq>(OptTrvSeq_Addr(parent), OptTrvSeq_N(parent));
11463}
11464
11465// --- fasttest.SeqTrvOpt.OptTrvSeq.Addr
11466fasttest::OptTrvSeq* fasttest::OptTrvSeq_Addr(fasttest::SeqTrvOpt& parent) {
11467    return (fasttest::OptTrvSeq*)((u8*)&parent + sizeof(fasttest::SeqTrvOpt)); // address of varlen portion
11468}
11469
11470// --- fasttest.SeqTrvOpt.OptTrvSeq.ReadStrptrMaybe
11471// Convert string to field. Return success value
11472bool fasttest::OptTrvSeq_ReadStrptrMaybe(fasttest::SeqTrvOpt& parent, algo::strptr in_str) {
11473    bool retval = true;
11474    if (algo_lib::_db.varlenbuf) {
11475        fasttest::OptTrvSeq *OptTrvSeq_tmp = new(ary_AllocN(*algo_lib::_db.varlenbuf, sizeof(fasttest::OptTrvSeq)).elems) fasttest::OptTrvSeq;
11476        retval = fasttest::OptTrvSeq_ReadStrptrMaybe(*OptTrvSeq_tmp, in_str);
11477    }
11478    (void)parent;//only to avoid -Wunused-parameter
11479    return retval;
11480}
11481
11482// --- fasttest.SeqTrvOpt..ReadFieldMaybe
11483bool fasttest::SeqTrvOpt_ReadFieldMaybe(fasttest::SeqTrvOpt& parent, algo::strptr field, algo::strptr strval) {
11484    bool retval = true;
11485    fasttest::FieldId field_id;
11486    (void)value_SetStrptrMaybe(field_id,algo::Pathcomp(field, ".LL"));
11487    switch(field_id) {
11488        case fasttest_FieldId_base: {
11489            retval = false;
11490            break;
11491        }
11492        case fasttest_FieldId_length: {
11493            retval = false;
11494            break;
11495        }
11496        case fasttest_FieldId_id: {
11497            retval = false;
11498            break;
11499        }
11500        case fasttest_FieldId_OptTrvSeq: {
11501            retval = OptTrvSeq_ReadStrptrMaybe(parent, strval);
11502            break;
11503        }
11504        default: break;
11505    }
11506    if (!retval) {
11507        algo_lib::AppendErrtext("attr",field);
11508    }
11509    return retval;
11510}
11511
11512// --- fasttest.SeqTrvOpt..ReadStrptrMaybe
11513// Any varlen fields are returned in algo_lib::_db.varlenbuf if set
11514// Read fields of fasttest::SeqTrvOpt from an ascii string.
11515// The format of the string is an ssim Tuple
11516bool fasttest::SeqTrvOpt_ReadStrptrMaybe(fasttest::SeqTrvOpt &parent, algo::strptr in_str) {
11517    bool retval = true;
11518    retval = algo::StripTypeTag(in_str, "fasttest.SeqTrvOpt");
11519    ind_beg(algo::Attr_curs, attr, in_str) {
11520        retval = retval && SeqTrvOpt_ReadFieldMaybe(parent, attr.name, attr.value);
11521    }ind_end;
11522    return retval;
11523}
11524
11525// --- fasttest.SeqTrvOpt..Print
11526// print string representation of ROW to string STR
11527// cfmt:fasttest.SeqTrvOpt.String  printfmt:Tuple
11528void fasttest::SeqTrvOpt_Print(fasttest::SeqTrvOpt& row, algo::cstring& str) {
11529    algo::tempstr temp;
11530    str << "fasttest.SeqTrvOpt";
11531
11532    ind_beg(SeqTrvOpt_OptTrvSeq_curs,OptTrvSeq,row) {
11533        fasttest::OptTrvSeq_Print(OptTrvSeq, temp);
11534        tempstr name;
11535        name << "OptTrvSeq.";
11536        name << ind_curs(OptTrvSeq).index;
11537        PrintAttrSpaceReset(str, name, temp);
11538    }ind_end;
11539}
11540
11541// --- fasttest.SeqTrvOpt..FastEncode
11542void fasttest::SeqTrvOpt_FastEncode(algo::ByteAry& buf, FastState& state, fasttest::SeqTrvOpt& parent) {
11543    int index = ary_N(buf);
11544    u64 pmap(0);
11545    if (!tid_AssignedQ(state) || parent.id != state.tid) {
11546        lib_fast::EncodeUnsigned(buf,parent.id,false);
11547        lib_fast::SetPmapBit(pmap,0);
11548    }
11549    tid_SetAssigned(state);
11550    state.tid = parent.id;
11551    // OptTrvSeq sequence none optional
11552    {
11553        u32 length = OptTrvSeq_N(parent);
11554        if (length) {
11555            lib_fast::EncodeUnsigned(buf,length,true);
11556        } else {
11557            lib_fast::EncodeNull(buf);
11558        }
11559        ind_beg(SeqTrvOpt_OptTrvSeq_curs,elem,parent) {
11560            OptTrvSeq_FastEncode(buf,state,elem);
11561        }ind_end;
11562    }
11563    lib_fast::InsertPmap(buf,index,pmap);
11564}
11565
11566// --- fasttest.SeqTrvOpt..FastDecode
11567bool fasttest::SeqTrvOpt_FastDecode(algo::memptr& from, u64 pmap, FastState& state, fasttest::SeqTrvOpt& parent) {
11568    bool ok = true;
11569    // OptTrvSeq sequence none optional
11570    if (ok) {
11571        u32 length(0);
11572        bool prs = !lib_fast::DecodeNull(from);
11573        if (prs) {
11574            ok = lib_fast::DecodeUnsigned(from,length,true);
11575            if (!ok) {
11576                state.error << "fasttest.SeqTrvOpt.OptTrvSeq: bad Unsigned" << eol;
11577            }
11578        }
11579        ;
11580        if (!ok) {
11581            state.error << "fasttest.SeqTrvOpt.OptTrvSeq: bad length" << eol;
11582        }
11583        length = prs ? length : 0;
11584        for (unsigned i=0; ok && i<length; ++i) {
11585            OptTrvSeq &seq = *new(ary_AllocN(lib_fast::_db.varlen,sizeof seq).elems) OptTrvSeq;
11586            ok = OptTrvSeq_FastDecode(from,state,seq);
11587            if (!ok) {
11588                state.error << "fasttest.SeqTrvOpt.OptTrvSeq: element #"<< i+1 << eol;
11589            }
11590        }
11591    }
11592    (void)pmap;//only to avoid -Wunused-parameter
11593    (void)parent;//only to avoid -Wunused-parameter
11594    return ok;
11595}
11596
11597// --- fasttest.SeqTrvOpt..FixEncode
11598void fasttest::SeqTrvOpt_FixEncode(cstring& buf, fasttest::SeqTrvOpt& parent, char soh) {
11599    ind_beg(SeqTrvOpt_OptTrvSeq_curs,elem,parent) {
11600        OptTrvSeq_FixEncode(buf,elem,soh);
11601    }ind_end;
11602}
11603
11604// --- fasttest.StrConst.base.CopyOut
11605// Copy fields out of row
11606void fasttest::parent_CopyOut(fasttest::StrConst &row, fasttest::TemplateHeader &out) {
11607    // length: field value is computed
11608    // id: field value is computed
11609    (void)row;//only to avoid -Wunused-parameter
11610    (void)out;//only to avoid -Wunused-parameter
11611}
11612
11613// --- fasttest.StrConst..ReadFieldMaybe
11614bool fasttest::StrConst_ReadFieldMaybe(fasttest::StrConst& parent, algo::strptr field, algo::strptr strval) {
11615    bool retval = true;
11616    fasttest::FieldId field_id;
11617    (void)value_SetStrptrMaybe(field_id,field);
11618    switch(field_id) {
11619        case fasttest_FieldId_base: {
11620            retval = false;
11621            break;
11622        }
11623        case fasttest_FieldId_length: {
11624            retval = false;
11625            break;
11626        }
11627        case fasttest_FieldId_id: {
11628            retval = false;
11629            break;
11630        }
11631        case fasttest_FieldId_Value: {
11632            retval = true;
11633            break;
11634        }
11635        default: break;
11636    }
11637    if (!retval) {
11638        algo_lib::AppendErrtext("attr",field);
11639    }
11640    (void)parent;//only to avoid -Wunused-parameter
11641    (void)strval;//only to avoid -Wunused-parameter
11642    return retval;
11643}
11644
11645// --- fasttest.StrConst..ReadStrptrMaybe
11646// Read fields of fasttest::StrConst from an ascii string.
11647// The format of the string is an ssim Tuple
11648bool fasttest::StrConst_ReadStrptrMaybe(fasttest::StrConst &parent, algo::strptr in_str) {
11649    bool retval = true;
11650    retval = algo::StripTypeTag(in_str, "fasttest.StrConst");
11651    ind_beg(algo::Attr_curs, attr, in_str) {
11652        retval = retval && StrConst_ReadFieldMaybe(parent, attr.name, attr.value);
11653    }ind_end;
11654    return retval;
11655}
11656
11657// --- fasttest.StrConst..Print
11658// print string representation of ROW to string STR
11659// cfmt:fasttest.StrConst.String  printfmt:Tuple
11660void fasttest::StrConst_Print(fasttest::StrConst& row, algo::cstring& str) {
11661    algo::tempstr temp;
11662    str << "fasttest.StrConst";
11663
11664    algo::strptr_Print(Value_Get(row), temp);
11665    PrintAttrSpaceReset(str,"Value", temp);
11666}
11667
11668// --- fasttest.StrConst..FastEncode
11669void fasttest::StrConst_FastEncode(algo::ByteAry& buf, FastState& state, fasttest::StrConst& parent) {
11670    int index = ary_N(buf);
11671    u64 pmap(0);
11672    if (!tid_AssignedQ(state) || parent.id != state.tid) {
11673        lib_fast::EncodeUnsigned(buf,parent.id,false);
11674        lib_fast::SetPmapBit(pmap,0);
11675    }
11676    tid_SetAssigned(state);
11677    state.tid = parent.id;
11678    // Value string constant mandatory
11679    lib_fast::InsertPmap(buf,index,pmap);
11680}
11681
11682// --- fasttest.StrConst..FastDecode
11683bool fasttest::StrConst_FastDecode(algo::memptr& from, u64 pmap, FastState& state, fasttest::StrConst& parent) {
11684    bool ok = true;
11685    // Value string constant mandatory
11686    if (ok) {
11687    }
11688    (void)from;//only to avoid -Wunused-parameter
11689    (void)pmap;//only to avoid -Wunused-parameter
11690    (void)state;//only to avoid -Wunused-parameter
11691    (void)parent;//only to avoid -Wunused-parameter
11692    return ok;
11693}
11694
11695// --- fasttest.StrConst..FixEncode
11696void fasttest::StrConst_FixEncode(cstring& buf, fasttest::StrConst& parent, char soh) {
11697    buf << "1=" << Value_Get(parent) << soh;
11698}
11699
11700// --- fasttest.StrConstOpt.base.CopyOut
11701// Copy fields out of row
11702void fasttest::parent_CopyOut(fasttest::StrConstOpt &row, fasttest::TemplateHeader &out) {
11703    // length: field value is computed
11704    // id: field value is computed
11705    (void)row;//only to avoid -Wunused-parameter
11706    (void)out;//only to avoid -Wunused-parameter
11707}
11708
11709// --- fasttest.StrConstOpt.pmask_bitcurs.Next
11710// proceed to next item
11711void fasttest::StrConstOpt_pmask_bitcurs_Next(StrConstOpt_pmask_bitcurs &curs) {
11712    ++curs.bit;
11713    int index = curs.bit / 32;
11714    int offset = curs.bit % 32;
11715    for (; index < curs.n_elems; ++index, offset = 0) {
11716        u64 rest = curs.elems[index] >> offset;
11717        if (rest) {
11718            offset += algo::u64_BitScanForward(rest);
11719            break;
11720        }
11721    }
11722    curs.bit = index * 32 + offset;
11723}
11724
11725// --- fasttest.StrConstOpt..ReadFieldMaybe
11726bool fasttest::StrConstOpt_ReadFieldMaybe(fasttest::StrConstOpt& parent, algo::strptr field, algo::strptr strval) {
11727    bool retval = true;
11728    fasttest::FieldId field_id;
11729    (void)value_SetStrptrMaybe(field_id,field);
11730    switch(field_id) {
11731        case fasttest_FieldId_base: {
11732            retval = false;
11733            break;
11734        }
11735        case fasttest_FieldId_length: {
11736            retval = false;
11737            break;
11738        }
11739        case fasttest_FieldId_id: {
11740            retval = false;
11741            break;
11742        }
11743        case fasttest_FieldId_pmask: {
11744            retval = false;
11745            break;
11746        }
11747        case fasttest_FieldId_Value: {
11748            retval = true;
11749            if (retval) {
11750                pmask_qSetBit(parent, 0);
11751            }
11752            break;
11753        }
11754        default: break;
11755    }
11756    if (!retval) {
11757        algo_lib::AppendErrtext("attr",field);
11758    }
11759    (void)strval;//only to avoid -Wunused-parameter
11760    return retval;
11761}
11762
11763// --- fasttest.StrConstOpt..ReadStrptrMaybe
11764// Read fields of fasttest::StrConstOpt from an ascii string.
11765// The format of the string is an ssim Tuple
11766bool fasttest::StrConstOpt_ReadStrptrMaybe(fasttest::StrConstOpt &parent, algo::strptr in_str) {
11767    bool retval = true;
11768    retval = algo::StripTypeTag(in_str, "fasttest.StrConstOpt");
11769    ind_beg(algo::Attr_curs, attr, in_str) {
11770        retval = retval && StrConstOpt_ReadFieldMaybe(parent, attr.name, attr.value);
11771    }ind_end;
11772    return retval;
11773}
11774
11775// --- fasttest.StrConstOpt..Print
11776// print string representation of ROW to string STR
11777// cfmt:fasttest.StrConstOpt.String  printfmt:Tuple
11778void fasttest::StrConstOpt_Print(fasttest::StrConstOpt& row, algo::cstring& str) {
11779    algo::tempstr temp;
11780    str << "fasttest.StrConstOpt";
11781
11782    if (Value_PresentQ(row)) {
11783        algo::strptr_Print(Value_Get(row), temp);
11784        PrintAttrSpaceReset(str,"Value", temp);
11785    }
11786}
11787
11788// --- fasttest.StrConstOpt..FastEncode
11789void fasttest::StrConstOpt_FastEncode(algo::ByteAry& buf, FastState& state, fasttest::StrConstOpt& parent) {
11790    int index = ary_N(buf);
11791    u64 pmap(0);
11792    if (!tid_AssignedQ(state) || parent.id != state.tid) {
11793        lib_fast::EncodeUnsigned(buf,parent.id,false);
11794        lib_fast::SetPmapBit(pmap,0);
11795    }
11796    tid_SetAssigned(state);
11797    state.tid = parent.id;
11798    // Value string constant optional
11799    if (Value_PresentQ(parent)) {
11800        lib_fast::SetPmapBit(pmap,1);
11801    }
11802    lib_fast::InsertPmap(buf,index,pmap);
11803}
11804
11805// --- fasttest.StrConstOpt..FastDecode
11806bool fasttest::StrConstOpt_FastDecode(algo::memptr& from, u64 pmap, FastState& state, fasttest::StrConstOpt& parent) {
11807    bool ok = true;
11808    // Value string constant optional
11809    if (ok) {
11810        bool prs = lib_fast::GetPmapBit(pmap,1);
11811        pmask_qSetBitVal(parent,Value_Present_GetBit(parent),prs);
11812    }
11813    (void)from;//only to avoid -Wunused-parameter
11814    (void)state;//only to avoid -Wunused-parameter
11815    return ok;
11816}
11817
11818// --- fasttest.StrConstOpt..FixEncode
11819void fasttest::StrConstOpt_FixEncode(cstring& buf, fasttest::StrConstOpt& parent, char soh) {
11820    if (Value_PresentQ(parent)) {
11821        buf << "1=" << Value_Get(parent) << soh;
11822    }
11823}
11824
11825// --- fasttest.StrCopy.base.CopyOut
11826// Copy fields out of row
11827void fasttest::parent_CopyOut(fasttest::StrCopy &row, fasttest::TemplateHeader &out) {
11828    // length: field value is computed
11829    // id: field value is computed
11830    (void)row;//only to avoid -Wunused-parameter
11831    (void)out;//only to avoid -Wunused-parameter
11832}
11833
11834// --- fasttest.StrCopy..ReadFieldMaybe
11835bool fasttest::StrCopy_ReadFieldMaybe(fasttest::StrCopy& parent, algo::strptr field, algo::strptr strval) {
11836    bool retval = true;
11837    fasttest::FieldId field_id;
11838    (void)value_SetStrptrMaybe(field_id,field);
11839    switch(field_id) {
11840        case fasttest_FieldId_base: {
11841            retval = false;
11842            break;
11843        }
11844        case fasttest_FieldId_length: {
11845            retval = false;
11846            break;
11847        }
11848        case fasttest_FieldId_id: {
11849            retval = false;
11850            break;
11851        }
11852        case fasttest_FieldId_Value55: {
11853            retval = algo::Smallstr30_ReadStrptrMaybe(parent.Value55, strval);
11854            break;
11855        }
11856        default: break;
11857    }
11858    if (!retval) {
11859        algo_lib::AppendErrtext("attr",field);
11860    }
11861    return retval;
11862}
11863
11864// --- fasttest.StrCopy..ReadStrptrMaybe
11865// Read fields of fasttest::StrCopy from an ascii string.
11866// The format of the string is an ssim Tuple
11867bool fasttest::StrCopy_ReadStrptrMaybe(fasttest::StrCopy &parent, algo::strptr in_str) {
11868    bool retval = true;
11869    retval = algo::StripTypeTag(in_str, "fasttest.StrCopy");
11870    ind_beg(algo::Attr_curs, attr, in_str) {
11871        retval = retval && StrCopy_ReadFieldMaybe(parent, attr.name, attr.value);
11872    }ind_end;
11873    return retval;
11874}
11875
11876// --- fasttest.StrCopy..Print
11877// print string representation of ROW to string STR
11878// cfmt:fasttest.StrCopy.String  printfmt:Tuple
11879void fasttest::StrCopy_Print(fasttest::StrCopy& row, algo::cstring& str) {
11880    algo::tempstr temp;
11881    str << "fasttest.StrCopy";
11882
11883    algo::Smallstr30_Print(row.Value55, temp);
11884    PrintAttrSpaceReset(str,"Value55", temp);
11885}
11886
11887// --- fasttest.StrCopy..FastEncode
11888void fasttest::StrCopy_FastEncode(algo::ByteAry& buf, FastState& state, fasttest::StrCopy& parent) {
11889    int index = ary_N(buf);
11890    u64 pmap(0);
11891    if (!tid_AssignedQ(state) || parent.id != state.tid) {
11892        lib_fast::EncodeUnsigned(buf,parent.id,false);
11893        lib_fast::SetPmapBit(pmap,0);
11894    }
11895    tid_SetAssigned(state);
11896    state.tid = parent.id;
11897    // Value55 string copy mandatory
11898    if (Value55_AssignedQ(state) ? parent.Value55 != state.Value55 : parent.Value55 != "A55") {
11899        lib_fast::EncodeString(buf,parent.Value55,false);
11900        lib_fast::SetPmapBit(pmap,1);
11901    }
11902    state.Value55 = parent.Value55;
11903    Value55_SetAssigned(state);
11904    lib_fast::InsertPmap(buf,index,pmap);
11905}
11906
11907// --- fasttest.StrCopy..FastDecode
11908bool fasttest::StrCopy_FastDecode(algo::memptr& from, u64 pmap, FastState& state, fasttest::StrCopy& parent) {
11909    bool ok = true;
11910    // Value55 string copy mandatory
11911    if (ok) {
11912        bool prs = lib_fast::GetPmapBit(pmap,1);
11913        if (prs) {
11914            ok = lib_fast::DecodeString(from,parent.Value55,false);
11915            if (!ok) {
11916                state.error << "fasttest.StrCopy.Value55: bad String" << eol;
11917            }
11918        } else if (Value55_AssignedQ(state)) {
11919            parent.Value55 = state.Value55;
11920        } else {
11921            parent.Value55 = "A55";
11922        }
11923        Value55_SetAssigned(state);
11924        state.Value55 = parent.Value55;
11925    }
11926    return ok;
11927}
11928
11929// --- fasttest.StrCopy..FixEncode
11930void fasttest::StrCopy_FixEncode(cstring& buf, fasttest::StrCopy& parent, char soh) {
11931    buf << "1=" << parent.Value55 << soh;
11932}
11933
11934// --- fasttest.StrCopyNull.base.CopyOut
11935// Copy fields out of row
11936void fasttest::parent_CopyOut(fasttest::StrCopyNull &row, fasttest::TemplateHeader &out) {
11937    // length: field value is computed
11938    // id: field value is computed
11939    (void)row;//only to avoid -Wunused-parameter
11940    (void)out;//only to avoid -Wunused-parameter
11941}
11942
11943// --- fasttest.StrCopyNull.Value57.ReadStrptrMaybe
11944inline static bool fasttest::Value57_ReadStrptrMaybe(fasttest::StrCopyNull &parent, algo::strptr in_str) {
11945    bool retval = true;
11946    algo::Smallstr30 Value57_tmp;
11947    retval = algo::Smallstr30_ReadStrptrMaybe(Value57_tmp, in_str);
11948    if (retval) {
11949        Value57_Set(parent, Value57_tmp);
11950    }
11951    return retval;
11952}
11953
11954// --- fasttest.StrCopyNull.pmask_bitcurs.Next
11955// proceed to next item
11956void fasttest::StrCopyNull_pmask_bitcurs_Next(StrCopyNull_pmask_bitcurs &curs) {
11957    ++curs.bit;
11958    int index = curs.bit / 32;
11959    int offset = curs.bit % 32;
11960    for (; index < curs.n_elems; ++index, offset = 0) {
11961        u64 rest = curs.elems[index] >> offset;
11962        if (rest) {
11963            offset += algo::u64_BitScanForward(rest);
11964            break;
11965        }
11966    }
11967    curs.bit = index * 32 + offset;
11968}
11969
11970// --- fasttest.StrCopyNull..ReadFieldMaybe
11971bool fasttest::StrCopyNull_ReadFieldMaybe(fasttest::StrCopyNull& parent, algo::strptr field, algo::strptr strval) {
11972    bool retval = true;
11973    fasttest::FieldId field_id;
11974    (void)value_SetStrptrMaybe(field_id,field);
11975    switch(field_id) {
11976        case fasttest_FieldId_base: {
11977            retval = false;
11978            break;
11979        }
11980        case fasttest_FieldId_length: {
11981            retval = false;
11982            break;
11983        }
11984        case fasttest_FieldId_id: {
11985            retval = false;
11986            break;
11987        }
11988        case fasttest_FieldId_pmask: {
11989            retval = false;
11990            break;
11991        }
11992        case fasttest_FieldId_Value57: {
11993            retval = Value57_ReadStrptrMaybe(parent, strval);
11994            if (retval) {
11995                pmask_qSetBit(parent, 0);
11996            }
11997            break;
11998        }
11999        default: break;
12000    }
12001    if (!retval) {
12002        algo_lib::AppendErrtext("attr",field);
12003    }
12004    return retval;
12005}
12006
12007// --- fasttest.StrCopyNull..ReadStrptrMaybe
12008// Read fields of fasttest::StrCopyNull from an ascii string.
12009// The format of the string is an ssim Tuple
12010bool fasttest::StrCopyNull_ReadStrptrMaybe(fasttest::StrCopyNull &parent, algo::strptr in_str) {
12011    bool retval = true;
12012    retval = algo::StripTypeTag(in_str, "fasttest.StrCopyNull");
12013    ind_beg(algo::Attr_curs, attr, in_str) {
12014        retval = retval && StrCopyNull_ReadFieldMaybe(parent, attr.name, attr.value);
12015    }ind_end;
12016    return retval;
12017}
12018
12019// --- fasttest.StrCopyNull..Print
12020// print string representation of ROW to string STR
12021// cfmt:fasttest.StrCopyNull.String  printfmt:Tuple
12022void fasttest::StrCopyNull_Print(fasttest::StrCopyNull& row, algo::cstring& str) {
12023    algo::tempstr temp;
12024    str << "fasttest.StrCopyNull";
12025
12026    if (Value57_PresentQ(row)) {
12027        algo::Smallstr30_Print(row.Value57, temp);
12028        PrintAttrSpaceReset(str,"Value57", temp);
12029    }
12030}
12031
12032// --- fasttest.StrCopyNull..FastEncode
12033void fasttest::StrCopyNull_FastEncode(algo::ByteAry& buf, FastState& state, fasttest::StrCopyNull& parent) {
12034    int index = ary_N(buf);
12035    u64 pmap(0);
12036    if (!tid_AssignedQ(state) || parent.id != state.tid) {
12037        lib_fast::EncodeUnsigned(buf,parent.id,false);
12038        lib_fast::SetPmapBit(pmap,0);
12039    }
12040    tid_SetAssigned(state);
12041    state.tid = parent.id;
12042    // Value57 string copy optional
12043    if (Value57_PresentQ(parent)) {
12044        if (!Value57_AssignedQ(state) || !Value57_PresentQ(state) ||  parent.Value57 != state.Value57 ) {
12045            lib_fast::EncodeString(buf,parent.Value57,true);
12046            lib_fast::SetPmapBit(pmap,1);
12047        }
12048    } else {
12049        if (Value57_AssignedQ(state)) {
12050            lib_fast::EncodeNull(buf);
12051            lib_fast::SetPmapBit(pmap,1);
12052        }
12053    }
12054    state.Value57 = parent.Value57;
12055    present_qSetBitVal(state,Value57_Present_GetBit(state),Value57_PresentQ(parent));
12056    Value57_SetAssigned(state);
12057    lib_fast::InsertPmap(buf,index,pmap);
12058}
12059
12060// --- fasttest.StrCopyNull..FastDecode
12061bool fasttest::StrCopyNull_FastDecode(algo::memptr& from, u64 pmap, FastState& state, fasttest::StrCopyNull& parent) {
12062    bool ok = true;
12063    // Value57 string copy optional
12064    if (ok) {
12065        bool prs = lib_fast::GetPmapBit(pmap,1);
12066        if (prs) {
12067            prs = !lib_fast::DecodeNull(from);
12068            if (prs) {
12069                ok = lib_fast::DecodeString(from,parent.Value57,true);
12070                if (!ok) {
12071                    state.error << "fasttest.StrCopyNull.Value57: bad String" << eol;
12072                }
12073            }
12074        } else if (Value57_AssignedQ(state)) {
12075            parent.Value57 = state.Value57;
12076            prs = Value57_PresentQ(state);
12077        } else {
12078            prs = false;
12079        }
12080        pmask_qSetBitVal(parent,Value57_Present_GetBit(parent),prs);
12081        Value57_SetAssigned(state);
12082        present_qSetBitVal(state,Value57_Present_GetBit(state),prs);
12083        state.Value57 = parent.Value57;
12084    }
12085    return ok;
12086}
12087
12088// --- fasttest.StrCopyNull..FixEncode
12089void fasttest::StrCopyNull_FixEncode(cstring& buf, fasttest::StrCopyNull& parent, char soh) {
12090    if (Value57_PresentQ(parent)) {
12091        buf << "1=" << parent.Value57 << soh;
12092    }
12093}
12094
12095// --- fasttest.StrCopyOpt.base.CopyOut
12096// Copy fields out of row
12097void fasttest::parent_CopyOut(fasttest::StrCopyOpt &row, fasttest::TemplateHeader &out) {
12098    // length: field value is computed
12099    // id: field value is computed
12100    (void)row;//only to avoid -Wunused-parameter
12101    (void)out;//only to avoid -Wunused-parameter
12102}
12103
12104// --- fasttest.StrCopyOpt.Value56.ReadStrptrMaybe
12105inline static bool fasttest::Value56_ReadStrptrMaybe(fasttest::StrCopyOpt &parent, algo::strptr in_str) {
12106    bool retval = true;
12107    algo::Smallstr30 Value56_tmp;
12108    retval = algo::Smallstr30_ReadStrptrMaybe(Value56_tmp, in_str);
12109    if (retval) {
12110        Value56_Set(parent, Value56_tmp);
12111    }
12112    return retval;
12113}
12114
12115// --- fasttest.StrCopyOpt.pmask_bitcurs.Next
12116// proceed to next item
12117void fasttest::StrCopyOpt_pmask_bitcurs_Next(StrCopyOpt_pmask_bitcurs &curs) {
12118    ++curs.bit;
12119    int index = curs.bit / 32;
12120    int offset = curs.bit % 32;
12121    for (; index < curs.n_elems; ++index, offset = 0) {
12122        u64 rest = curs.elems[index] >> offset;
12123        if (rest) {
12124            offset += algo::u64_BitScanForward(rest);
12125            break;
12126        }
12127    }
12128    curs.bit = index * 32 + offset;
12129}
12130
12131// --- fasttest.StrCopyOpt..ReadFieldMaybe
12132bool fasttest::StrCopyOpt_ReadFieldMaybe(fasttest::StrCopyOpt& parent, algo::strptr field, algo::strptr strval) {
12133    bool retval = true;
12134    fasttest::FieldId field_id;
12135    (void)value_SetStrptrMaybe(field_id,field);
12136    switch(field_id) {
12137        case fasttest_FieldId_base: {
12138            retval = false;
12139            break;
12140        }
12141        case fasttest_FieldId_length: {
12142            retval = false;
12143            break;
12144        }
12145        case fasttest_FieldId_id: {
12146            retval = false;
12147            break;
12148        }
12149        case fasttest_FieldId_pmask: {
12150            retval = false;
12151            break;
12152        }
12153        case fasttest_FieldId_Value56: {
12154            retval = Value56_ReadStrptrMaybe(parent, strval);
12155            if (retval) {
12156                pmask_qSetBit(parent, 0);
12157            }
12158            break;
12159        }
12160        default: break;
12161    }
12162    if (!retval) {
12163        algo_lib::AppendErrtext("attr",field);
12164    }
12165    return retval;
12166}
12167
12168// --- fasttest.StrCopyOpt..ReadStrptrMaybe
12169// Read fields of fasttest::StrCopyOpt from an ascii string.
12170// The format of the string is an ssim Tuple
12171bool fasttest::StrCopyOpt_ReadStrptrMaybe(fasttest::StrCopyOpt &parent, algo::strptr in_str) {
12172    bool retval = true;
12173    retval = algo::StripTypeTag(in_str, "fasttest.StrCopyOpt");
12174    ind_beg(algo::Attr_curs, attr, in_str) {
12175        retval = retval && StrCopyOpt_ReadFieldMaybe(parent, attr.name, attr.value);
12176    }ind_end;
12177    return retval;
12178}
12179
12180// --- fasttest.StrCopyOpt..Print
12181// print string representation of ROW to string STR
12182// cfmt:fasttest.StrCopyOpt.String  printfmt:Tuple
12183void fasttest::StrCopyOpt_Print(fasttest::StrCopyOpt& row, algo::cstring& str) {
12184    algo::tempstr temp;
12185    str << "fasttest.StrCopyOpt";
12186
12187    if (Value56_PresentQ(row)) {
12188        algo::Smallstr30_Print(row.Value56, temp);
12189        PrintAttrSpaceReset(str,"Value56", temp);
12190    }
12191}
12192
12193// --- fasttest.StrCopyOpt..FastEncode
12194void fasttest::StrCopyOpt_FastEncode(algo::ByteAry& buf, FastState& state, fasttest::StrCopyOpt& parent) {
12195    int index = ary_N(buf);
12196    u64 pmap(0);
12197    if (!tid_AssignedQ(state) || parent.id != state.tid) {
12198        lib_fast::EncodeUnsigned(buf,parent.id,false);
12199        lib_fast::SetPmapBit(pmap,0);
12200    }
12201    tid_SetAssigned(state);
12202    state.tid = parent.id;
12203    // Value56 string copy optional
12204    if (Value56_PresentQ(parent)) {
12205        if (Value56_AssignedQ(state) ? !Value56_PresentQ(state) || parent.Value56 != state.Value56 : parent.Value56 != "A56") {
12206            lib_fast::EncodeString(buf,parent.Value56,true);
12207            lib_fast::SetPmapBit(pmap,1);
12208        }
12209    } else {
12210        if (Value56_AssignedQ(state) && Value56_PresentQ(state)) {
12211            lib_fast::EncodeNull(buf);
12212            lib_fast::SetPmapBit(pmap,1);
12213        }
12214    }
12215    state.Value56 = parent.Value56;
12216    present_qSetBitVal(state,Value56_Present_GetBit(state),Value56_PresentQ(parent));
12217    Value56_SetAssigned(state);
12218    lib_fast::InsertPmap(buf,index,pmap);
12219}
12220
12221// --- fasttest.StrCopyOpt..FastDecode
12222bool fasttest::StrCopyOpt_FastDecode(algo::memptr& from, u64 pmap, FastState& state, fasttest::StrCopyOpt& parent) {
12223    bool ok = true;
12224    // Value56 string copy optional
12225    if (ok) {
12226        bool prs = lib_fast::GetPmapBit(pmap,1);
12227        if (prs) {
12228            prs = !lib_fast::DecodeNull(from);
12229            if (prs) {
12230                ok = lib_fast::DecodeString(from,parent.Value56,true);
12231                if (!ok) {
12232                    state.error << "fasttest.StrCopyOpt.Value56: bad String" << eol;
12233                }
12234            }
12235        } else if (Value56_AssignedQ(state)) {
12236            parent.Value56 = state.Value56;
12237            prs = Value56_PresentQ(state);
12238        } else {
12239            parent.Value56 = "A56";
12240            prs = true;
12241        }
12242        pmask_qSetBitVal(parent,Value56_Present_GetBit(parent),prs);
12243        Value56_SetAssigned(state);
12244        present_qSetBitVal(state,Value56_Present_GetBit(state),prs);
12245        state.Value56 = parent.Value56;
12246    }
12247    return ok;
12248}
12249
12250// --- fasttest.StrCopyOpt..FixEncode
12251void fasttest::StrCopyOpt_FixEncode(cstring& buf, fasttest::StrCopyOpt& parent, char soh) {
12252    if (Value56_PresentQ(parent)) {
12253        buf << "1=" << parent.Value56 << soh;
12254    }
12255}
12256
12257// --- fasttest.StrDflt.base.CopyOut
12258// Copy fields out of row
12259void fasttest::parent_CopyOut(fasttest::StrDflt &row, fasttest::TemplateHeader &out) {
12260    // length: field value is computed
12261    // id: field value is computed
12262    (void)row;//only to avoid -Wunused-parameter
12263    (void)out;//only to avoid -Wunused-parameter
12264}
12265
12266// --- fasttest.StrDflt..ReadFieldMaybe
12267bool fasttest::StrDflt_ReadFieldMaybe(fasttest::StrDflt& parent, algo::strptr field, algo::strptr strval) {
12268    bool retval = true;
12269    fasttest::FieldId field_id;
12270    (void)value_SetStrptrMaybe(field_id,field);
12271    switch(field_id) {
12272        case fasttest_FieldId_base: {
12273            retval = false;
12274            break;
12275        }
12276        case fasttest_FieldId_length: {
12277            retval = false;
12278            break;
12279        }
12280        case fasttest_FieldId_id: {
12281            retval = false;
12282            break;
12283        }
12284        case fasttest_FieldId_Value: {
12285            retval = algo::Smallstr30_ReadStrptrMaybe(parent.Value, strval);
12286            break;
12287        }
12288        default: break;
12289    }
12290    if (!retval) {
12291        algo_lib::AppendErrtext("attr",field);
12292    }
12293    return retval;
12294}
12295
12296// --- fasttest.StrDflt..ReadStrptrMaybe
12297// Read fields of fasttest::StrDflt from an ascii string.
12298// The format of the string is an ssim Tuple
12299bool fasttest::StrDflt_ReadStrptrMaybe(fasttest::StrDflt &parent, algo::strptr in_str) {
12300    bool retval = true;
12301    retval = algo::StripTypeTag(in_str, "fasttest.StrDflt");
12302    ind_beg(algo::Attr_curs, attr, in_str) {
12303        retval = retval && StrDflt_ReadFieldMaybe(parent, attr.name, attr.value);
12304    }ind_end;
12305    return retval;
12306}
12307
12308// --- fasttest.StrDflt..Print
12309// print string representation of ROW to string STR
12310// cfmt:fasttest.StrDflt.String  printfmt:Tuple
12311void fasttest::StrDflt_Print(fasttest::StrDflt& row, algo::cstring& str) {
12312    algo::tempstr temp;
12313    str << "fasttest.StrDflt";
12314
12315    algo::Smallstr30_Print(row.Value, temp);
12316    PrintAttrSpaceReset(str,"Value", temp);
12317}
12318
12319// --- fasttest.StrDflt..FastEncode
12320void fasttest::StrDflt_FastEncode(algo::ByteAry& buf, FastState& state, fasttest::StrDflt& parent) {
12321    int index = ary_N(buf);
12322    u64 pmap(0);
12323    if (!tid_AssignedQ(state) || parent.id != state.tid) {
12324        lib_fast::EncodeUnsigned(buf,parent.id,false);
12325        lib_fast::SetPmapBit(pmap,0);
12326    }
12327    tid_SetAssigned(state);
12328    state.tid = parent.id;
12329    // Value string default mandatory
12330    if (parent.Value != "A39") {
12331        lib_fast::EncodeString(buf,parent.Value,false);
12332        lib_fast::SetPmapBit(pmap,1);
12333    }
12334    lib_fast::InsertPmap(buf,index,pmap);
12335}
12336
12337// --- fasttest.StrDflt..FastDecode
12338bool fasttest::StrDflt_FastDecode(algo::memptr& from, u64 pmap, FastState& state, fasttest::StrDflt& parent) {
12339    bool ok = true;
12340    // Value string default mandatory
12341    if (ok) {
12342        bool prs = lib_fast::GetPmapBit(pmap,1);
12343        if (prs) {
12344            ok = lib_fast::DecodeString(from,parent.Value,false);
12345            if (!ok) {
12346                state.error << "fasttest.StrDflt.Value: bad String" << eol;
12347            }
12348        } else {
12349            parent.Value = "A39";
12350        }
12351    }
12352    return ok;
12353}
12354
12355// --- fasttest.StrDflt..FixEncode
12356void fasttest::StrDflt_FixEncode(cstring& buf, fasttest::StrDflt& parent, char soh) {
12357    buf << "1=" << parent.Value << soh;
12358}
12359
12360// --- fasttest.StrDfltNull.base.CopyOut
12361// Copy fields out of row
12362void fasttest::parent_CopyOut(fasttest::StrDfltNull &row, fasttest::TemplateHeader &out) {
12363    // length: field value is computed
12364    // id: field value is computed
12365    (void)row;//only to avoid -Wunused-parameter
12366    (void)out;//only to avoid -Wunused-parameter
12367}
12368
12369// --- fasttest.StrDfltNull.Value.ReadStrptrMaybe
12370inline static bool fasttest::Value_ReadStrptrMaybe(fasttest::StrDfltNull &parent, algo::strptr in_str) {
12371    bool retval = true;
12372    algo::Smallstr30 Value_tmp;
12373    retval = algo::Smallstr30_ReadStrptrMaybe(Value_tmp, in_str);
12374    if (retval) {
12375        Value_Set(parent, Value_tmp);
12376    }
12377    return retval;
12378}
12379
12380// --- fasttest.StrDfltNull.pmask_bitcurs.Next
12381// proceed to next item
12382void fasttest::StrDfltNull_pmask_bitcurs_Next(StrDfltNull_pmask_bitcurs &curs) {
12383    ++curs.bit;
12384    int index = curs.bit / 32;
12385    int offset = curs.bit % 32;
12386    for (; index < curs.n_elems; ++index, offset = 0) {
12387        u64 rest = curs.elems[index] >> offset;
12388        if (rest) {
12389            offset += algo::u64_BitScanForward(rest);
12390            break;
12391        }
12392    }
12393    curs.bit = index * 32 + offset;
12394}
12395
12396// --- fasttest.StrDfltNull..ReadFieldMaybe
12397bool fasttest::StrDfltNull_ReadFieldMaybe(fasttest::StrDfltNull& parent, algo::strptr field, algo::strptr strval) {
12398    bool retval = true;
12399    fasttest::FieldId field_id;
12400    (void)value_SetStrptrMaybe(field_id,field);
12401    switch(field_id) {
12402        case fasttest_FieldId_base: {
12403            retval = false;
12404            break;
12405        }
12406        case fasttest_FieldId_length: {
12407            retval = false;
12408            break;
12409        }
12410        case fasttest_FieldId_id: {
12411            retval = false;
12412            break;
12413        }
12414        case fasttest_FieldId_pmask: {
12415            retval = false;
12416            break;
12417        }
12418        case fasttest_FieldId_Value: {
12419            retval = Value_ReadStrptrMaybe(parent, strval);
12420            if (retval) {
12421                pmask_qSetBit(parent, 0);
12422            }
12423            break;
12424        }
12425        default: break;
12426    }
12427    if (!retval) {
12428        algo_lib::AppendErrtext("attr",field);
12429    }
12430    return retval;
12431}
12432
12433// --- fasttest.StrDfltNull..ReadStrptrMaybe
12434// Read fields of fasttest::StrDfltNull from an ascii string.
12435// The format of the string is an ssim Tuple
12436bool fasttest::StrDfltNull_ReadStrptrMaybe(fasttest::StrDfltNull &parent, algo::strptr in_str) {
12437    bool retval = true;
12438    retval = algo::StripTypeTag(in_str, "fasttest.StrDfltNull");
12439    ind_beg(algo::Attr_curs, attr, in_str) {
12440        retval = retval && StrDfltNull_ReadFieldMaybe(parent, attr.name, attr.value);
12441    }ind_end;
12442    return retval;
12443}
12444
12445// --- fasttest.StrDfltNull..Print
12446// print string representation of ROW to string STR
12447// cfmt:fasttest.StrDfltNull.String  printfmt:Tuple
12448void fasttest::StrDfltNull_Print(fasttest::StrDfltNull& row, algo::cstring& str) {
12449    algo::tempstr temp;
12450    str << "fasttest.StrDfltNull";
12451
12452    if (Value_PresentQ(row)) {
12453        algo::Smallstr30_Print(row.Value, temp);
12454        PrintAttrSpaceReset(str,"Value", temp);
12455    }
12456}
12457
12458// --- fasttest.StrDfltNull..FastEncode
12459void fasttest::StrDfltNull_FastEncode(algo::ByteAry& buf, FastState& state, fasttest::StrDfltNull& parent) {
12460    int index = ary_N(buf);
12461    u64 pmap(0);
12462    if (!tid_AssignedQ(state) || parent.id != state.tid) {
12463        lib_fast::EncodeUnsigned(buf,parent.id,false);
12464        lib_fast::SetPmapBit(pmap,0);
12465    }
12466    tid_SetAssigned(state);
12467    state.tid = parent.id;
12468    // Value string default optional
12469    if (Value_PresentQ(parent)) {
12470        lib_fast::EncodeString(buf,parent.Value,true);
12471        lib_fast::SetPmapBit(pmap,1);
12472    }
12473    lib_fast::InsertPmap(buf,index,pmap);
12474}
12475
12476// --- fasttest.StrDfltNull..FastDecode
12477bool fasttest::StrDfltNull_FastDecode(algo::memptr& from, u64 pmap, FastState& state, fasttest::StrDfltNull& parent) {
12478    bool ok = true;
12479    // Value string default optional
12480    if (ok) {
12481        bool prs = lib_fast::GetPmapBit(pmap,1);
12482        if (prs) {
12483            prs = !lib_fast::DecodeNull(from);
12484            if (prs) {
12485                ok = lib_fast::DecodeString(from,parent.Value,true);
12486                if (!ok) {
12487                    state.error << "fasttest.StrDfltNull.Value: bad String" << eol;
12488                }
12489            }
12490        } else {
12491        }
12492        pmask_qSetBitVal(parent,Value_Present_GetBit(parent),prs);
12493    }
12494    return ok;
12495}
12496
12497// --- fasttest.StrDfltNull..FixEncode
12498void fasttest::StrDfltNull_FixEncode(cstring& buf, fasttest::StrDfltNull& parent, char soh) {
12499    if (Value_PresentQ(parent)) {
12500        buf << "1=" << parent.Value << soh;
12501    }
12502}
12503
12504// --- fasttest.StrDfltOpt.base.CopyOut
12505// Copy fields out of row
12506void fasttest::parent_CopyOut(fasttest::StrDfltOpt &row, fasttest::TemplateHeader &out) {
12507    // length: field value is computed
12508    // id: field value is computed
12509    (void)row;//only to avoid -Wunused-parameter
12510    (void)out;//only to avoid -Wunused-parameter
12511}
12512
12513// --- fasttest.StrDfltOpt.Value.ReadStrptrMaybe
12514inline static bool fasttest::Value_ReadStrptrMaybe(fasttest::StrDfltOpt &parent, algo::strptr in_str) {
12515    bool retval = true;
12516    algo::Smallstr30 Value_tmp;
12517    retval = algo::Smallstr30_ReadStrptrMaybe(Value_tmp, in_str);
12518    if (retval) {
12519        Value_Set(parent, Value_tmp);
12520    }
12521    return retval;
12522}
12523
12524// --- fasttest.StrDfltOpt.pmask_bitcurs.Next
12525// proceed to next item
12526void fasttest::StrDfltOpt_pmask_bitcurs_Next(StrDfltOpt_pmask_bitcurs &curs) {
12527    ++curs.bit;
12528    int index = curs.bit / 32;
12529    int offset = curs.bit % 32;
12530    for (; index < curs.n_elems; ++index, offset = 0) {
12531        u64 rest = curs.elems[index] >> offset;
12532        if (rest) {
12533            offset += algo::u64_BitScanForward(rest);
12534            break;
12535        }
12536    }
12537    curs.bit = index * 32 + offset;
12538}
12539
12540// --- fasttest.StrDfltOpt..ReadFieldMaybe
12541bool fasttest::StrDfltOpt_ReadFieldMaybe(fasttest::StrDfltOpt& parent, algo::strptr field, algo::strptr strval) {
12542    bool retval = true;
12543    fasttest::FieldId field_id;
12544    (void)value_SetStrptrMaybe(field_id,field);
12545    switch(field_id) {
12546        case fasttest_FieldId_base: {
12547            retval = false;
12548            break;
12549        }
12550        case fasttest_FieldId_length: {
12551            retval = false;
12552            break;
12553        }
12554        case fasttest_FieldId_id: {
12555            retval = false;
12556            break;
12557        }
12558        case fasttest_FieldId_pmask: {
12559            retval = false;
12560            break;
12561        }
12562        case fasttest_FieldId_Value: {
12563            retval = Value_ReadStrptrMaybe(parent, strval);
12564            if (retval) {
12565                pmask_qSetBit(parent, 0);
12566            }
12567            break;
12568        }
12569        default: break;
12570    }
12571    if (!retval) {
12572        algo_lib::AppendErrtext("attr",field);
12573    }
12574    return retval;
12575}
12576
12577// --- fasttest.StrDfltOpt..ReadStrptrMaybe
12578// Read fields of fasttest::StrDfltOpt from an ascii string.
12579// The format of the string is an ssim Tuple
12580bool fasttest::StrDfltOpt_ReadStrptrMaybe(fasttest::StrDfltOpt &parent, algo::strptr in_str) {
12581    bool retval = true;
12582    retval = algo::StripTypeTag(in_str, "fasttest.StrDfltOpt");
12583    ind_beg(algo::Attr_curs, attr, in_str) {
12584        retval = retval && StrDfltOpt_ReadFieldMaybe(parent, attr.name, attr.value);
12585    }ind_end;
12586    return retval;
12587}
12588
12589// --- fasttest.StrDfltOpt..Print
12590// print string representation of ROW to string STR
12591// cfmt:fasttest.StrDfltOpt.String  printfmt:Tuple
12592void fasttest::StrDfltOpt_Print(fasttest::StrDfltOpt& row, algo::cstring& str) {
12593    algo::tempstr temp;
12594    str << "fasttest.StrDfltOpt";
12595
12596    if (Value_PresentQ(row)) {
12597        algo::Smallstr30_Print(row.Value, temp);
12598        PrintAttrSpaceReset(str,"Value", temp);
12599    }
12600}
12601
12602// --- fasttest.StrDfltOpt..FastEncode
12603void fasttest::StrDfltOpt_FastEncode(algo::ByteAry& buf, FastState& state, fasttest::StrDfltOpt& parent) {
12604    int index = ary_N(buf);
12605    u64 pmap(0);
12606    if (!tid_AssignedQ(state) || parent.id != state.tid) {
12607        lib_fast::EncodeUnsigned(buf,parent.id,false);
12608        lib_fast::SetPmapBit(pmap,0);
12609    }
12610    tid_SetAssigned(state);
12611    state.tid = parent.id;
12612    // Value string default optional
12613    if (Value_PresentQ(parent)) {
12614        if (parent.Value != "A40") {
12615            lib_fast::EncodeString(buf,parent.Value,true);
12616            lib_fast::SetPmapBit(pmap,1);
12617        }
12618    } else {
12619        lib_fast::EncodeNull(buf);
12620        lib_fast::SetPmapBit(pmap,1);
12621    }
12622    lib_fast::InsertPmap(buf,index,pmap);
12623}
12624
12625// --- fasttest.StrDfltOpt..FastDecode
12626bool fasttest::StrDfltOpt_FastDecode(algo::memptr& from, u64 pmap, FastState& state, fasttest::StrDfltOpt& parent) {
12627    bool ok = true;
12628    // Value string default optional
12629    if (ok) {
12630        bool prs = lib_fast::GetPmapBit(pmap,1);
12631        if (prs) {
12632            prs = !lib_fast::DecodeNull(from);
12633            if (prs) {
12634                ok = lib_fast::DecodeString(from,parent.Value,true);
12635                if (!ok) {
12636                    state.error << "fasttest.StrDfltOpt.Value: bad String" << eol;
12637                }
12638            }
12639        } else {
12640            parent.Value = "A40";
12641            prs = true;
12642        }
12643        pmask_qSetBitVal(parent,Value_Present_GetBit(parent),prs);
12644    }
12645    return ok;
12646}
12647
12648// --- fasttest.StrDfltOpt..FixEncode
12649void fasttest::StrDfltOpt_FixEncode(cstring& buf, fasttest::StrDfltOpt& parent, char soh) {
12650    if (Value_PresentQ(parent)) {
12651        buf << "1=" << parent.Value << soh;
12652    }
12653}
12654
12655// --- fasttest.StrNone.base.CopyOut
12656// Copy fields out of row
12657void fasttest::parent_CopyOut(fasttest::StrNone &row, fasttest::TemplateHeader &out) {
12658    // length: field value is computed
12659    // id: field value is computed
12660    (void)row;//only to avoid -Wunused-parameter
12661    (void)out;//only to avoid -Wunused-parameter
12662}
12663
12664// --- fasttest.StrNone..ReadFieldMaybe
12665bool fasttest::StrNone_ReadFieldMaybe(fasttest::StrNone& parent, algo::strptr field, algo::strptr strval) {
12666    bool retval = true;
12667    fasttest::FieldId field_id;
12668    (void)value_SetStrptrMaybe(field_id,field);
12669    switch(field_id) {
12670        case fasttest_FieldId_base: {
12671            retval = false;
12672            break;
12673        }
12674        case fasttest_FieldId_length: {
12675            retval = false;
12676            break;
12677        }
12678        case fasttest_FieldId_id: {
12679            retval = false;
12680            break;
12681        }
12682        case fasttest_FieldId_Value: {
12683            retval = algo::Smallstr30_ReadStrptrMaybe(parent.Value, strval);
12684            break;
12685        }
12686        default: break;
12687    }
12688    if (!retval) {
12689        algo_lib::AppendErrtext("attr",field);
12690    }
12691    return retval;
12692}
12693
12694// --- fasttest.StrNone..ReadStrptrMaybe
12695// Read fields of fasttest::StrNone from an ascii string.
12696// The format of the string is an ssim Tuple
12697bool fasttest::StrNone_ReadStrptrMaybe(fasttest::StrNone &parent, algo::strptr in_str) {
12698    bool retval = true;
12699    retval = algo::StripTypeTag(in_str, "fasttest.StrNone");
12700    ind_beg(algo::Attr_curs, attr, in_str) {
12701        retval = retval && StrNone_ReadFieldMaybe(parent, attr.name, attr.value);
12702    }ind_end;
12703    return retval;
12704}
12705
12706// --- fasttest.StrNone..Print
12707// print string representation of ROW to string STR
12708// cfmt:fasttest.StrNone.String  printfmt:Tuple
12709void fasttest::StrNone_Print(fasttest::StrNone& row, algo::cstring& str) {
12710    algo::tempstr temp;
12711    str << "fasttest.StrNone";
12712
12713    algo::Smallstr30_Print(row.Value, temp);
12714    PrintAttrSpaceReset(str,"Value", temp);
12715}
12716
12717// --- fasttest.StrNone..FastEncode
12718void fasttest::StrNone_FastEncode(algo::ByteAry& buf, FastState& state, fasttest::StrNone& parent) {
12719    int index = ary_N(buf);
12720    u64 pmap(0);
12721    if (!tid_AssignedQ(state) || parent.id != state.tid) {
12722        lib_fast::EncodeUnsigned(buf,parent.id,false);
12723        lib_fast::SetPmapBit(pmap,0);
12724    }
12725    tid_SetAssigned(state);
12726    state.tid = parent.id;
12727    // Value string none mandatory
12728    lib_fast::EncodeString(buf,parent.Value,false);
12729    lib_fast::InsertPmap(buf,index,pmap);
12730}
12731
12732// --- fasttest.StrNone..FastDecode
12733bool fasttest::StrNone_FastDecode(algo::memptr& from, u64 pmap, FastState& state, fasttest::StrNone& parent) {
12734    bool ok = true;
12735    // Value string none mandatory
12736    if (ok) {
12737        ok = lib_fast::DecodeString(from,parent.Value,false);
12738        if (!ok) {
12739            state.error << "fasttest.StrNone.Value: bad String" << eol;
12740        }
12741    }
12742    (void)pmap;//only to avoid -Wunused-parameter
12743    return ok;
12744}
12745
12746// --- fasttest.StrNone..FixEncode
12747void fasttest::StrNone_FixEncode(cstring& buf, fasttest::StrNone& parent, char soh) {
12748    buf << "1=" << parent.Value << soh;
12749}
12750
12751// --- fasttest.StrNoneOpt.base.CopyOut
12752// Copy fields out of row
12753void fasttest::parent_CopyOut(fasttest::StrNoneOpt &row, fasttest::TemplateHeader &out) {
12754    // length: field value is computed
12755    // id: field value is computed
12756    (void)row;//only to avoid -Wunused-parameter
12757    (void)out;//only to avoid -Wunused-parameter
12758}
12759
12760// --- fasttest.StrNoneOpt.Value.ReadStrptrMaybe
12761inline static bool fasttest::Value_ReadStrptrMaybe(fasttest::StrNoneOpt &parent, algo::strptr in_str) {
12762    bool retval = true;
12763    algo::Smallstr30 Value_tmp;
12764    retval = algo::Smallstr30_ReadStrptrMaybe(Value_tmp, in_str);
12765    if (retval) {
12766        Value_Set(parent, Value_tmp);
12767    }
12768    return retval;
12769}
12770
12771// --- fasttest.StrNoneOpt.pmask_bitcurs.Next
12772// proceed to next item
12773void fasttest::StrNoneOpt_pmask_bitcurs_Next(StrNoneOpt_pmask_bitcurs &curs) {
12774    ++curs.bit;
12775    int index = curs.bit / 32;
12776    int offset = curs.bit % 32;
12777    for (; index < curs.n_elems; ++index, offset = 0) {
12778        u64 rest = curs.elems[index] >> offset;
12779        if (rest) {
12780            offset += algo::u64_BitScanForward(rest);
12781            break;
12782        }
12783    }
12784    curs.bit = index * 32 + offset;
12785}
12786
12787// --- fasttest.StrNoneOpt..ReadFieldMaybe
12788bool fasttest::StrNoneOpt_ReadFieldMaybe(fasttest::StrNoneOpt& parent, algo::strptr field, algo::strptr strval) {
12789    bool retval = true;
12790    fasttest::FieldId field_id;
12791    (void)value_SetStrptrMaybe(field_id,field);
12792    switch(field_id) {
12793        case fasttest_FieldId_base: {
12794            retval = false;
12795            break;
12796        }
12797        case fasttest_FieldId_length: {
12798            retval = false;
12799            break;
12800        }
12801        case fasttest_FieldId_id: {
12802            retval = false;
12803            break;
12804        }
12805        case fasttest_FieldId_pmask: {
12806            retval = false;
12807            break;
12808        }
12809        case fasttest_FieldId_Value: {
12810            retval = Value_ReadStrptrMaybe(parent, strval);
12811            if (retval) {
12812                pmask_qSetBit(parent, 0);
12813            }
12814            break;
12815        }
12816        default: break;
12817    }
12818    if (!retval) {
12819        algo_lib::AppendErrtext("attr",field);
12820    }
12821    return retval;
12822}
12823
12824// --- fasttest.StrNoneOpt..ReadStrptrMaybe
12825// Read fields of fasttest::StrNoneOpt from an ascii string.
12826// The format of the string is an ssim Tuple
12827bool fasttest::StrNoneOpt_ReadStrptrMaybe(fasttest::StrNoneOpt &parent, algo::strptr in_str) {
12828    bool retval = true;
12829    retval = algo::StripTypeTag(in_str, "fasttest.StrNoneOpt");
12830    ind_beg(algo::Attr_curs, attr, in_str) {
12831        retval = retval && StrNoneOpt_ReadFieldMaybe(parent, attr.name, attr.value);
12832    }ind_end;
12833    return retval;
12834}
12835
12836// --- fasttest.StrNoneOpt..Print
12837// print string representation of ROW to string STR
12838// cfmt:fasttest.StrNoneOpt.String  printfmt:Tuple
12839void fasttest::StrNoneOpt_Print(fasttest::StrNoneOpt& row, algo::cstring& str) {
12840    algo::tempstr temp;
12841    str << "fasttest.StrNoneOpt";
12842
12843    if (Value_PresentQ(row)) {
12844        algo::Smallstr30_Print(row.Value, temp);
12845        PrintAttrSpaceReset(str,"Value", temp);
12846    }
12847}
12848
12849// --- fasttest.StrNoneOpt..FastEncode
12850void fasttest::StrNoneOpt_FastEncode(algo::ByteAry& buf, FastState& state, fasttest::StrNoneOpt& parent) {
12851    int index = ary_N(buf);
12852    u64 pmap(0);
12853    if (!tid_AssignedQ(state) || parent.id != state.tid) {
12854        lib_fast::EncodeUnsigned(buf,parent.id,false);
12855        lib_fast::SetPmapBit(pmap,0);
12856    }
12857    tid_SetAssigned(state);
12858    state.tid = parent.id;
12859    // Value string none optional
12860    if (Value_PresentQ(parent)) {
12861        lib_fast::EncodeString(buf,parent.Value,true);
12862    } else {
12863        lib_fast::EncodeNull(buf);
12864    }
12865    lib_fast::InsertPmap(buf,index,pmap);
12866}
12867
12868// --- fasttest.StrNoneOpt..FastDecode
12869bool fasttest::StrNoneOpt_FastDecode(algo::memptr& from, u64 pmap, FastState& state, fasttest::StrNoneOpt& parent) {
12870    bool ok = true;
12871    // Value string none optional
12872    if (ok) {
12873        bool prs = !lib_fast::DecodeNull(from);
12874        if (prs) {
12875            ok = lib_fast::DecodeString(from,parent.Value,true);
12876            if (!ok) {
12877                state.error << "fasttest.StrNoneOpt.Value: bad String" << eol;
12878            }
12879        }
12880        pmask_qSetBitVal(parent,Value_Present_GetBit(parent),prs);
12881    }
12882    (void)pmap;//only to avoid -Wunused-parameter
12883    return ok;
12884}
12885
12886// --- fasttest.StrNoneOpt..FixEncode
12887void fasttest::StrNoneOpt_FixEncode(cstring& buf, fasttest::StrNoneOpt& parent, char soh) {
12888    if (Value_PresentQ(parent)) {
12889        buf << "1=" << parent.Value << soh;
12890    }
12891}
12892
12893// --- fasttest.TemplateHeader.id.ToCstr
12894// Convert numeric value of field to one of predefined string constants.
12895// If string is found, return a static C string. Otherwise, return NULL.
12896const char* fasttest::id_ToCstr(const fasttest::TemplateHeader& parent) {
12897    const char *ret = NULL;
12898    switch(id_GetEnum(parent)) {
12899        case fasttest_TemplateHeader_id_fasttest_BVConst: ret = "fasttest.BVConst";  break;
12900        case fasttest_TemplateHeader_id_fasttest_BVConstOpt: ret = "fasttest.BVConstOpt";  break;
12901        case fasttest_TemplateHeader_id_fasttest_BVCopy: ret = "fasttest.BVCopy";  break;
12902        case fasttest_TemplateHeader_id_fasttest_BVCopyNull: ret = "fasttest.BVCopyNull";  break;
12903        case fasttest_TemplateHeader_id_fasttest_BVCopyOpt: ret = "fasttest.BVCopyOpt";  break;
12904        case fasttest_TemplateHeader_id_fasttest_BVDflt: ret = "fasttest.BVDflt";  break;
12905        case fasttest_TemplateHeader_id_fasttest_BVDfltNull: ret = "fasttest.BVDfltNull";  break;
12906        case fasttest_TemplateHeader_id_fasttest_BVDfltOpt: ret = "fasttest.BVDfltOpt";  break;
12907        case fasttest_TemplateHeader_id_fasttest_BVNone: ret = "fasttest.BVNone";  break;
12908        case fasttest_TemplateHeader_id_fasttest_BVNoneOpt: ret = "fasttest.BVNoneOpt";  break;
12909        case fasttest_TemplateHeader_id_fasttest_GroupSgmOpt: ret = "fasttest.GroupSgmOpt";  break;
12910        case fasttest_TemplateHeader_id_fasttest_GroupTrv: ret = "fasttest.GroupTrv";  break;
12911        case fasttest_TemplateHeader_id_fasttest_GroupTrvOpt: ret = "fasttest.GroupTrvOpt";  break;
12912        case fasttest_TemplateHeader_id_fasttest_I32Const: ret = "fasttest.I32Const";  break;
12913        case fasttest_TemplateHeader_id_fasttest_I32ConstOpt: ret = "fasttest.I32ConstOpt";  break;
12914        case fasttest_TemplateHeader_id_fasttest_I32Copy: ret = "fasttest.I32Copy";  break;
12915        case fasttest_TemplateHeader_id_fasttest_I32CopyNull: ret = "fasttest.I32CopyNull";  break;
12916        case fasttest_TemplateHeader_id_fasttest_I32CopyOpt: ret = "fasttest.I32CopyOpt";  break;
12917        case fasttest_TemplateHeader_id_fasttest_I32Delta: ret = "fasttest.I32Delta";  break;
12918        case fasttest_TemplateHeader_id_fasttest_I32DeltaImpl: ret = "fasttest.I32DeltaImpl";  break;
12919        case fasttest_TemplateHeader_id_fasttest_I32DeltaNull: ret = "fasttest.I32DeltaNull";  break;
12920        case fasttest_TemplateHeader_id_fasttest_I32DeltaOpt: ret = "fasttest.I32DeltaOpt";  break;
12921        case fasttest_TemplateHeader_id_fasttest_I32Dflt: ret = "fasttest.I32Dflt";  break;
12922        case fasttest_TemplateHeader_id_fasttest_I32DfltNull: ret = "fasttest.I32DfltNull";  break;
12923        case fasttest_TemplateHeader_id_fasttest_I32DfltOpt: ret = "fasttest.I32DfltOpt";  break;
12924        case fasttest_TemplateHeader_id_fasttest_I32Incr: ret = "fasttest.I32Incr";  break;
12925        case fasttest_TemplateHeader_id_fasttest_I32IncrNV: ret = "fasttest.I32IncrNV";  break;
12926        case fasttest_TemplateHeader_id_fasttest_I32IncrNull: ret = "fasttest.I32IncrNull";  break;
12927        case fasttest_TemplateHeader_id_fasttest_I32IncrOpt: ret = "fasttest.I32IncrOpt";  break;
12928        case fasttest_TemplateHeader_id_fasttest_I32None: ret = "fasttest.I32None";  break;
12929        case fasttest_TemplateHeader_id_fasttest_I32NoneOpt: ret = "fasttest.I32NoneOpt";  break;
12930        case fasttest_TemplateHeader_id_fasttest_MsgPmap: ret = "fasttest.MsgPmap";  break;
12931        case fasttest_TemplateHeader_id_fasttest_Reset: ret = "fasttest.Reset";  break;
12932        case fasttest_TemplateHeader_id_fasttest_SampleEnumConst: ret = "fasttest.SampleEnumConst";  break;
12933        case fasttest_TemplateHeader_id_fasttest_SampleEnumCopy: ret = "fasttest.SampleEnumCopy";  break;
12934        case fasttest_TemplateHeader_id_fasttest_SampleEnumDefault: ret = "fasttest.SampleEnumDefault";  break;
12935        case fasttest_TemplateHeader_id_fasttest_SampleSetConst: ret = "fasttest.SampleSetConst";  break;
12936        case fasttest_TemplateHeader_id_fasttest_SampleSetCopy: ret = "fasttest.SampleSetCopy";  break;
12937        case fasttest_TemplateHeader_id_fasttest_SampleSetDefault: ret = "fasttest.SampleSetDefault";  break;
12938        case fasttest_TemplateHeader_id_fasttest_SclConst: ret = "fasttest.SclConst";  break;
12939        case fasttest_TemplateHeader_id_fasttest_SclConstOpt: ret = "fasttest.SclConstOpt";  break;
12940        case fasttest_TemplateHeader_id_fasttest_SclCopy: ret = "fasttest.SclCopy";  break;
12941        case fasttest_TemplateHeader_id_fasttest_SclCopyNull: ret = "fasttest.SclCopyNull";  break;
12942        case fasttest_TemplateHeader_id_fasttest_SclCopyOpt: ret = "fasttest.SclCopyOpt";  break;
12943        case fasttest_TemplateHeader_id_fasttest_SclDelta: ret = "fasttest.SclDelta";  break;
12944        case fasttest_TemplateHeader_id_fasttest_SclDeltaImpl: ret = "fasttest.SclDeltaImpl";  break;
12945        case fasttest_TemplateHeader_id_fasttest_SclDeltaNull: ret = "fasttest.SclDeltaNull";  break;
12946        case fasttest_TemplateHeader_id_fasttest_SclDeltaOpt: ret = "fasttest.SclDeltaOpt";  break;
12947        case fasttest_TemplateHeader_id_fasttest_SclDflt: ret = "fasttest.SclDflt";  break;
12948        case fasttest_TemplateHeader_id_fasttest_SclDfltNull: ret = "fasttest.SclDfltNull";  break;
12949        case fasttest_TemplateHeader_id_fasttest_SclDfltOpt: ret = "fasttest.SclDfltOpt";  break;
12950        case fasttest_TemplateHeader_id_fasttest_SclNone: ret = "fasttest.SclNone";  break;
12951        case fasttest_TemplateHeader_id_fasttest_SclNoneOpt: ret = "fasttest.SclNoneOpt";  break;
12952        case fasttest_TemplateHeader_id_fasttest_SeqOrder: ret = "fasttest.SeqOrder";  break;
12953        case fasttest_TemplateHeader_id_fasttest_SeqSgmOpt: ret = "fasttest.SeqSgmOpt";  break;
12954        case fasttest_TemplateHeader_id_fasttest_SeqTrv: ret = "fasttest.SeqTrv";  break;
12955        case fasttest_TemplateHeader_id_fasttest_SeqTrvLenConst: ret = "fasttest.SeqTrvLenConst";  break;
12956        case fasttest_TemplateHeader_id_fasttest_SeqTrvLenConstOpt: ret = "fasttest.SeqTrvLenConstOpt";  break;
12957        case fasttest_TemplateHeader_id_fasttest_SeqTrvLenDflt: ret = "fasttest.SeqTrvLenDflt";  break;
12958        case fasttest_TemplateHeader_id_fasttest_SeqTrvLenDfltOpt: ret = "fasttest.SeqTrvLenDfltOpt";  break;
12959        case fasttest_TemplateHeader_id_fasttest_SeqTrvLenNone: ret = "fasttest.SeqTrvLenNone";  break;
12960        case fasttest_TemplateHeader_id_fasttest_SeqTrvLenNoneOpt: ret = "fasttest.SeqTrvLenNoneOpt";  break;
12961        case fasttest_TemplateHeader_id_fasttest_SeqTrvOpt: ret = "fasttest.SeqTrvOpt";  break;
12962        case fasttest_TemplateHeader_id_fasttest_StrConst: ret = "fasttest.StrConst";  break;
12963        case fasttest_TemplateHeader_id_fasttest_StrConstOpt: ret = "fasttest.StrConstOpt";  break;
12964        case fasttest_TemplateHeader_id_fasttest_StrCopy: ret = "fasttest.StrCopy";  break;
12965        case fasttest_TemplateHeader_id_fasttest_StrCopyNull: ret = "fasttest.StrCopyNull";  break;
12966        case fasttest_TemplateHeader_id_fasttest_StrCopyOpt: ret = "fasttest.StrCopyOpt";  break;
12967        case fasttest_TemplateHeader_id_fasttest_StrDflt: ret = "fasttest.StrDflt";  break;
12968        case fasttest_TemplateHeader_id_fasttest_StrDfltNull: ret = "fasttest.StrDfltNull";  break;
12969        case fasttest_TemplateHeader_id_fasttest_StrDfltOpt: ret = "fasttest.StrDfltOpt";  break;
12970        case fasttest_TemplateHeader_id_fasttest_StrNone: ret = "fasttest.StrNone";  break;
12971        case fasttest_TemplateHeader_id_fasttest_StrNoneOpt: ret = "fasttest.StrNoneOpt";  break;
12972        case fasttest_TemplateHeader_id_fasttest_U32Const: ret = "fasttest.U32Const";  break;
12973        case fasttest_TemplateHeader_id_fasttest_U32ConstOpt: ret = "fasttest.U32ConstOpt";  break;
12974        case fasttest_TemplateHeader_id_fasttest_U32Copy: ret = "fasttest.U32Copy";  break;
12975        case fasttest_TemplateHeader_id_fasttest_U32CopyNull: ret = "fasttest.U32CopyNull";  break;
12976        case fasttest_TemplateHeader_id_fasttest_U32CopyOpt: ret = "fasttest.U32CopyOpt";  break;
12977        case fasttest_TemplateHeader_id_fasttest_U32Delta: ret = "fasttest.U32Delta";  break;
12978        case fasttest_TemplateHeader_id_fasttest_U32DeltaImpl: ret = "fasttest.U32DeltaImpl";  break;
12979        case fasttest_TemplateHeader_id_fasttest_U32DeltaNull: ret = "fasttest.U32DeltaNull";  break;
12980        case fasttest_TemplateHeader_id_fasttest_U32DeltaOpt: ret = "fasttest.U32DeltaOpt";  break;
12981        case fasttest_TemplateHeader_id_fasttest_U32Dflt: ret = "fasttest.U32Dflt";  break;
12982        case fasttest_TemplateHeader_id_fasttest_U32DfltNull: ret = "fasttest.U32DfltNull";  break;
12983        case fasttest_TemplateHeader_id_fasttest_U32DfltOpt: ret = "fasttest.U32DfltOpt";  break;
12984        case fasttest_TemplateHeader_id_fasttest_U32Incr: ret = "fasttest.U32Incr";  break;
12985        case fasttest_TemplateHeader_id_fasttest_U32IncrNV: ret = "fasttest.U32IncrNV";  break;
12986        case fasttest_TemplateHeader_id_fasttest_U32IncrNull: ret = "fasttest.U32IncrNull";  break;
12987        case fasttest_TemplateHeader_id_fasttest_U32IncrOpt: ret = "fasttest.U32IncrOpt";  break;
12988        case fasttest_TemplateHeader_id_fasttest_U32None: ret = "fasttest.U32None";  break;
12989        case fasttest_TemplateHeader_id_fasttest_U32NoneOpt: ret = "fasttest.U32NoneOpt";  break;
12990    }
12991    return ret;
12992}
12993
12994// --- fasttest.TemplateHeader.id.Print
12995// Convert id to a string. First, attempt conversion to a known string.
12996// If no string matches, print id as a numeric value.
12997void fasttest::id_Print(const fasttest::TemplateHeader& parent, algo::cstring &lhs) {
12998    const char *strval = id_ToCstr(parent);
12999    if (strval) {
13000        lhs << strval;
13001    } else {
13002        lhs << parent.id;
13003    }
13004}
13005
13006// --- fasttest.TemplateHeader.id.SetStrptrMaybe
13007// Convert string to field.
13008// If the string is invalid, do not modify field and return false.
13009// In case of success, return true
13010bool fasttest::id_SetStrptrMaybe(fasttest::TemplateHeader& parent, algo::strptr rhs) {
13011    bool ret = false;
13012    switch (elems_N(rhs)) {
13013        case 14: {
13014            switch (algo::ReadLE64(rhs.elems)) {
13015                case LE_STR8('f','a','s','t','t','e','s','t'): {
13016                    if (memcmp(rhs.elems+8,".Reset",6)==0) { id_SetEnum(parent,fasttest_TemplateHeader_id_fasttest_Reset); ret = true; break; }
13017                    break;
13018                }
13019            }
13020            break;
13021        }
13022        case 15: {
13023            switch (algo::ReadLE64(rhs.elems)) {
13024                case LE_STR8('f','a','s','t','t','e','s','t'): {
13025                    if (memcmp(rhs.elems+8,".BVCopy",7)==0) { id_SetEnum(parent,fasttest_TemplateHeader_id_fasttest_BVCopy); ret = true; break; }
13026                    if (memcmp(rhs.elems+8,".BVDflt",7)==0) { id_SetEnum(parent,fasttest_TemplateHeader_id_fasttest_BVDflt); ret = true; break; }
13027                    if (memcmp(rhs.elems+8,".BVNone",7)==0) { id_SetEnum(parent,fasttest_TemplateHeader_id_fasttest_BVNone); ret = true; break; }
13028                    if (memcmp(rhs.elems+8,".SeqTrv",7)==0) { id_SetEnum(parent,fasttest_TemplateHeader_id_fasttest_SeqTrv); ret = true; break; }
13029                    break;
13030                }
13031            }
13032            break;
13033        }
13034        case 16: {
13035            switch (algo::ReadLE64(rhs.elems)) {
13036                case LE_STR8('f','a','s','t','t','e','s','t'): {
13037                    if (memcmp(rhs.elems+8,".BVConst",8)==0) { id_SetEnum(parent,fasttest_TemplateHeader_id_fasttest_BVConst); ret = true; break; }
13038                    if (memcmp(rhs.elems+8,".I32Copy",8)==0) { id_SetEnum(parent,fasttest_TemplateHeader_id_fasttest_I32Copy); ret = true; break; }
13039                    if (memcmp(rhs.elems+8,".I32Dflt",8)==0) { id_SetEnum(parent,fasttest_TemplateHeader_id_fasttest_I32Dflt); ret = true; break; }
13040                    if (memcmp(rhs.elems+8,".I32Incr",8)==0) { id_SetEnum(parent,fasttest_TemplateHeader_id_fasttest_I32Incr); ret = true; break; }
13041                    if (memcmp(rhs.elems+8,".I32None",8)==0) { id_SetEnum(parent,fasttest_TemplateHeader_id_fasttest_I32None); ret = true; break; }
13042                    if (memcmp(rhs.elems+8,".MsgPmap",8)==0) { id_SetEnum(parent,fasttest_TemplateHeader_id_fasttest_MsgPmap); ret = true; break; }
13043                    if (memcmp(rhs.elems+8,".SclCopy",8)==0) { id_SetEnum(parent,fasttest_TemplateHeader_id_fasttest_SclCopy); ret = true; break; }
13044                    if (memcmp(rhs.elems+8,".SclDflt",8)==0) { id_SetEnum(parent,fasttest_TemplateHeader_id_fasttest_SclDflt); ret = true; break; }
13045                    if (memcmp(rhs.elems+8,".SclNone",8)==0) { id_SetEnum(parent,fasttest_TemplateHeader_id_fasttest_SclNone); ret = true; break; }
13046                    if (memcmp(rhs.elems+8,".StrCopy",8)==0) { id_SetEnum(parent,fasttest_TemplateHeader_id_fasttest_StrCopy); ret = true; break; }
13047                    if (memcmp(rhs.elems+8,".StrDflt",8)==0) { id_SetEnum(parent,fasttest_TemplateHeader_id_fasttest_StrDflt); ret = true; break; }
13048                    if (memcmp(rhs.elems+8,".StrNone",8)==0) { id_SetEnum(parent,fasttest_TemplateHeader_id_fasttest_StrNone); ret = true; break; }
13049                    if (memcmp(rhs.elems+8,".U32Copy",8)==0) { id_SetEnum(parent,fasttest_TemplateHeader_id_fasttest_U32Copy); ret = true; break; }
13050                    if (memcmp(rhs.elems+8,".U32Dflt",8)==0) { id_SetEnum(parent,fasttest_TemplateHeader_id_fasttest_U32Dflt); ret = true; break; }
13051                    if (memcmp(rhs.elems+8,".U32Incr",8)==0) { id_SetEnum(parent,fasttest_TemplateHeader_id_fasttest_U32Incr); ret = true; break; }
13052                    if (memcmp(rhs.elems+8,".U32None",8)==0) { id_SetEnum(parent,fasttest_TemplateHeader_id_fasttest_U32None); ret = true; break; }
13053                    break;
13054                }
13055            }
13056            break;
13057        }
13058        case 17: {
13059            switch (algo::ReadLE64(rhs.elems)) {
13060                case LE_STR8('f','a','s','t','t','e','s','t'): {
13061                    if (memcmp(rhs.elems+8,".GroupTrv",9)==0) { id_SetEnum(parent,fasttest_TemplateHeader_id_fasttest_GroupTrv); ret = true; break; }
13062                    if (memcmp(rhs.elems+8,".I32Const",9)==0) { id_SetEnum(parent,fasttest_TemplateHeader_id_fasttest_I32Const); ret = true; break; }
13063                    if (memcmp(rhs.elems+8,".I32Delta",9)==0) { id_SetEnum(parent,fasttest_TemplateHeader_id_fasttest_I32Delta); ret = true; break; }
13064                    if (memcmp(rhs.elems+8,".SclConst",9)==0) { id_SetEnum(parent,fasttest_TemplateHeader_id_fasttest_SclConst); ret = true; break; }
13065                    if (memcmp(rhs.elems+8,".SclDelta",9)==0) { id_SetEnum(parent,fasttest_TemplateHeader_id_fasttest_SclDelta); ret = true; break; }
13066                    if (memcmp(rhs.elems+8,".SeqOrder",9)==0) { id_SetEnum(parent,fasttest_TemplateHeader_id_fasttest_SeqOrder); ret = true; break; }
13067                    if (memcmp(rhs.elems+8,".StrConst",9)==0) { id_SetEnum(parent,fasttest_TemplateHeader_id_fasttest_StrConst); ret = true; break; }
13068                    if (memcmp(rhs.elems+8,".U32Const",9)==0) { id_SetEnum(parent,fasttest_TemplateHeader_id_fasttest_U32Const); ret = true; break; }
13069                    if (memcmp(rhs.elems+8,".U32Delta",9)==0) { id_SetEnum(parent,fasttest_TemplateHeader_id_fasttest_U32Delta); ret = true; break; }
13070                    break;
13071                }
13072            }
13073            break;
13074        }
13075        case 18: {
13076            switch (algo::ReadLE64(rhs.elems)) {
13077                case LE_STR8('f','a','s','t','t','e','s','t'): {
13078                    if (memcmp(rhs.elems+8,".BVCopyOpt",10)==0) { id_SetEnum(parent,fasttest_TemplateHeader_id_fasttest_BVCopyOpt); ret = true; break; }
13079                    if (memcmp(rhs.elems+8,".BVDfltOpt",10)==0) { id_SetEnum(parent,fasttest_TemplateHeader_id_fasttest_BVDfltOpt); ret = true; break; }
13080                    if (memcmp(rhs.elems+8,".BVNoneOpt",10)==0) { id_SetEnum(parent,fasttest_TemplateHeader_id_fasttest_BVNoneOpt); ret = true; break; }
13081                    if (memcmp(rhs.elems+8,".I32IncrNV",10)==0) { id_SetEnum(parent,fasttest_TemplateHeader_id_fasttest_I32IncrNV); ret = true; break; }
13082                    if (memcmp(rhs.elems+8,".SeqSgmOpt",10)==0) { id_SetEnum(parent,fasttest_TemplateHeader_id_fasttest_SeqSgmOpt); ret = true; break; }
13083                    if (memcmp(rhs.elems+8,".SeqTrvOpt",10)==0) { id_SetEnum(parent,fasttest_TemplateHeader_id_fasttest_SeqTrvOpt); ret = true; break; }
13084                    if (memcmp(rhs.elems+8,".U32IncrNV",10)==0) { id_SetEnum(parent,fasttest_TemplateHeader_id_fasttest_U32IncrNV); ret = true; break; }
13085                    break;
13086                }
13087            }
13088            break;
13089        }
13090        case 19: {
13091            switch (algo::ReadLE64(rhs.elems)) {
13092                case LE_STR8('f','a','s','t','t','e','s','t'): {
13093                    if (memcmp(rhs.elems+8,".BVConstOpt",11)==0) { id_SetEnum(parent,fasttest_TemplateHeader_id_fasttest_BVConstOpt); ret = true; break; }
13094                    if (memcmp(rhs.elems+8,".BVCopyNull",11)==0) { id_SetEnum(parent,fasttest_TemplateHeader_id_fasttest_BVCopyNull); ret = true; break; }
13095                    if (memcmp(rhs.elems+8,".BVDfltNull",11)==0) { id_SetEnum(parent,fasttest_TemplateHeader_id_fasttest_BVDfltNull); ret = true; break; }
13096                    if (memcmp(rhs.elems+8,".I32CopyOpt",11)==0) { id_SetEnum(parent,fasttest_TemplateHeader_id_fasttest_I32CopyOpt); ret = true; break; }
13097                    if (memcmp(rhs.elems+8,".I32DfltOpt",11)==0) { id_SetEnum(parent,fasttest_TemplateHeader_id_fasttest_I32DfltOpt); ret = true; break; }
13098                    if (memcmp(rhs.elems+8,".I32IncrOpt",11)==0) { id_SetEnum(parent,fasttest_TemplateHeader_id_fasttest_I32IncrOpt); ret = true; break; }
13099                    if (memcmp(rhs.elems+8,".I32NoneOpt",11)==0) { id_SetEnum(parent,fasttest_TemplateHeader_id_fasttest_I32NoneOpt); ret = true; break; }
13100                    if (memcmp(rhs.elems+8,".SclCopyOpt",11)==0) { id_SetEnum(parent,fasttest_TemplateHeader_id_fasttest_SclCopyOpt); ret = true; break; }
13101                    if (memcmp(rhs.elems+8,".SclDfltOpt",11)==0) { id_SetEnum(parent,fasttest_TemplateHeader_id_fasttest_SclDfltOpt); ret = true; break; }
13102                    if (memcmp(rhs.elems+8,".SclNoneOpt",11)==0) { id_SetEnum(parent,fasttest_TemplateHeader_id_fasttest_SclNoneOpt); ret = true; break; }
13103                    if (memcmp(rhs.elems+8,".StrCopyOpt",11)==0) { id_SetEnum(parent,fasttest_TemplateHeader_id_fasttest_StrCopyOpt); ret = true; break; }
13104                    if (memcmp(rhs.elems+8,".StrDfltOpt",11)==0) { id_SetEnum(parent,fasttest_TemplateHeader_id_fasttest_StrDfltOpt); ret = true; break; }
13105                    if (memcmp(rhs.elems+8,".StrNoneOpt",11)==0) { id_SetEnum(parent,fasttest_TemplateHeader_id_fasttest_StrNoneOpt); ret = true; break; }
13106                    if (memcmp(rhs.elems+8,".U32CopyOpt",11)==0) { id_SetEnum(parent,fasttest_TemplateHeader_id_fasttest_U32CopyOpt); ret = true; break; }
13107                    if (memcmp(rhs.elems+8,".U32DfltOpt",11)==0) { id_SetEnum(parent,fasttest_TemplateHeader_id_fasttest_U32DfltOpt); ret = true; break; }
13108                    if (memcmp(rhs.elems+8,".U32IncrOpt",11)==0) { id_SetEnum(parent,fasttest_TemplateHeader_id_fasttest_U32IncrOpt); ret = true; break; }
13109                    if (memcmp(rhs.elems+8,".U32NoneOpt",11)==0) { id_SetEnum(parent,fasttest_TemplateHeader_id_fasttest_U32NoneOpt); ret = true; break; }
13110                    break;
13111                }
13112            }
13113            break;
13114        }
13115        case 20: {
13116            switch (algo::ReadLE64(rhs.elems)) {
13117                case LE_STR8('f','a','s','t','t','e','s','t'): {
13118                    if (memcmp(rhs.elems+8,".GroupSgmOpt",12)==0) { id_SetEnum(parent,fasttest_TemplateHeader_id_fasttest_GroupSgmOpt); ret = true; break; }
13119                    if (memcmp(rhs.elems+8,".GroupTrvOpt",12)==0) { id_SetEnum(parent,fasttest_TemplateHeader_id_fasttest_GroupTrvOpt); ret = true; break; }
13120                    if (memcmp(rhs.elems+8,".I32ConstOpt",12)==0) { id_SetEnum(parent,fasttest_TemplateHeader_id_fasttest_I32ConstOpt); ret = true; break; }
13121                    if (memcmp(rhs.elems+8,".I32CopyNull",12)==0) { id_SetEnum(parent,fasttest_TemplateHeader_id_fasttest_I32CopyNull); ret = true; break; }
13122                    if (memcmp(rhs.elems+8,".I32DeltaOpt",12)==0) { id_SetEnum(parent,fasttest_TemplateHeader_id_fasttest_I32DeltaOpt); ret = true; break; }
13123                    if (memcmp(rhs.elems+8,".I32DfltNull",12)==0) { id_SetEnum(parent,fasttest_TemplateHeader_id_fasttest_I32DfltNull); ret = true; break; }
13124                    if (memcmp(rhs.elems+8,".I32IncrNull",12)==0) { id_SetEnum(parent,fasttest_TemplateHeader_id_fasttest_I32IncrNull); ret = true; break; }
13125                    if (memcmp(rhs.elems+8,".SclConstOpt",12)==0) { id_SetEnum(parent,fasttest_TemplateHeader_id_fasttest_SclConstOpt); ret = true; break; }
13126                    if (memcmp(rhs.elems+8,".SclCopyNull",12)==0) { id_SetEnum(parent,fasttest_TemplateHeader_id_fasttest_SclCopyNull); ret = true; break; }
13127                    if (memcmp(rhs.elems+8,".SclDeltaOpt",12)==0) { id_SetEnum(parent,fasttest_TemplateHeader_id_fasttest_SclDeltaOpt); ret = true; break; }
13128                    if (memcmp(rhs.elems+8,".SclDfltNull",12)==0) { id_SetEnum(parent,fasttest_TemplateHeader_id_fasttest_SclDfltNull); ret = true; break; }
13129                    if (memcmp(rhs.elems+8,".StrConstOpt",12)==0) { id_SetEnum(parent,fasttest_TemplateHeader_id_fasttest_StrConstOpt); ret = true; break; }
13130                    if (memcmp(rhs.elems+8,".StrCopyNull",12)==0) { id_SetEnum(parent,fasttest_TemplateHeader_id_fasttest_StrCopyNull); ret = true; break; }
13131                    if (memcmp(rhs.elems+8,".StrDfltNull",12)==0) { id_SetEnum(parent,fasttest_TemplateHeader_id_fasttest_StrDfltNull); ret = true; break; }
13132                    if (memcmp(rhs.elems+8,".U32ConstOpt",12)==0) { id_SetEnum(parent,fasttest_TemplateHeader_id_fasttest_U32ConstOpt); ret = true; break; }
13133                    if (memcmp(rhs.elems+8,".U32CopyNull",12)==0) { id_SetEnum(parent,fasttest_TemplateHeader_id_fasttest_U32CopyNull); ret = true; break; }
13134                    if (memcmp(rhs.elems+8,".U32DeltaOpt",12)==0) { id_SetEnum(parent,fasttest_TemplateHeader_id_fasttest_U32DeltaOpt); ret = true; break; }
13135                    if (memcmp(rhs.elems+8,".U32DfltNull",12)==0) { id_SetEnum(parent,fasttest_TemplateHeader_id_fasttest_U32DfltNull); ret = true; break; }
13136                    if (memcmp(rhs.elems+8,".U32IncrNull",12)==0) { id_SetEnum(parent,fasttest_TemplateHeader_id_fasttest_U32IncrNull); ret = true; break; }
13137                    break;
13138                }
13139            }
13140            break;
13141        }
13142        case 21: {
13143            switch (algo::ReadLE64(rhs.elems)) {
13144                case LE_STR8('f','a','s','t','t','e','s','t'): {
13145                    if (memcmp(rhs.elems+8,".I32DeltaImpl",13)==0) { id_SetEnum(parent,fasttest_TemplateHeader_id_fasttest_I32DeltaImpl); ret = true; break; }
13146                    if (memcmp(rhs.elems+8,".I32DeltaNull",13)==0) { id_SetEnum(parent,fasttest_TemplateHeader_id_fasttest_I32DeltaNull); ret = true; break; }
13147                    if (memcmp(rhs.elems+8,".SclDeltaImpl",13)==0) { id_SetEnum(parent,fasttest_TemplateHeader_id_fasttest_SclDeltaImpl); ret = true; break; }
13148                    if (memcmp(rhs.elems+8,".SclDeltaNull",13)==0) { id_SetEnum(parent,fasttest_TemplateHeader_id_fasttest_SclDeltaNull); ret = true; break; }
13149                    if (memcmp(rhs.elems+8,".U32DeltaImpl",13)==0) { id_SetEnum(parent,fasttest_TemplateHeader_id_fasttest_U32DeltaImpl); ret = true; break; }
13150                    if (memcmp(rhs.elems+8,".U32DeltaNull",13)==0) { id_SetEnum(parent,fasttest_TemplateHeader_id_fasttest_U32DeltaNull); ret = true; break; }
13151                    break;
13152                }
13153            }
13154            break;
13155        }
13156        case 22: {
13157            switch (algo::ReadLE64(rhs.elems)) {
13158                case LE_STR8('f','a','s','t','t','e','s','t'): {
13159                    if (memcmp(rhs.elems+8,".SampleSetCopy",14)==0) { id_SetEnum(parent,fasttest_TemplateHeader_id_fasttest_SampleSetCopy); ret = true; break; }
13160                    if (memcmp(rhs.elems+8,".SeqTrvLenDflt",14)==0) { id_SetEnum(parent,fasttest_TemplateHeader_id_fasttest_SeqTrvLenDflt); ret = true; break; }
13161                    if (memcmp(rhs.elems+8,".SeqTrvLenNone",14)==0) { id_SetEnum(parent,fasttest_TemplateHeader_id_fasttest_SeqTrvLenNone); ret = true; break; }
13162                    break;
13163                }
13164            }
13165            break;
13166        }
13167        case 23: {
13168            switch (algo::ReadLE64(rhs.elems)) {
13169                case LE_STR8('f','a','s','t','t','e','s','t'): {
13170                    if (memcmp(rhs.elems+8,".SampleEnumCopy",15)==0) { id_SetEnum(parent,fasttest_TemplateHeader_id_fasttest_SampleEnumCopy); ret = true; break; }
13171                    if (memcmp(rhs.elems+8,".SampleSetConst",15)==0) { id_SetEnum(parent,fasttest_TemplateHeader_id_fasttest_SampleSetConst); ret = true; break; }
13172                    if (memcmp(rhs.elems+8,".SeqTrvLenConst",15)==0) { id_SetEnum(parent,fasttest_TemplateHeader_id_fasttest_SeqTrvLenConst); ret = true; break; }
13173                    break;
13174                }
13175            }
13176            break;
13177        }
13178        case 24: {
13179            switch (algo::ReadLE64(rhs.elems)) {
13180                case LE_STR8('f','a','s','t','t','e','s','t'): {
13181                    if (memcmp(rhs.elems+8,".SampleEnumConst",16)==0) { id_SetEnum(parent,fasttest_TemplateHeader_id_fasttest_SampleEnumConst); ret = true; break; }
13182                    break;
13183                }
13184            }
13185            break;
13186        }
13187        case 25: {
13188            switch (algo::ReadLE64(rhs.elems)) {
13189                case LE_STR8('f','a','s','t','t','e','s','t'): {
13190                    if (memcmp(rhs.elems+8,".SampleSetDefault",17)==0) { id_SetEnum(parent,fasttest_TemplateHeader_id_fasttest_SampleSetDefault); ret = true; break; }
13191                    if (memcmp(rhs.elems+8,".SeqTrvLenDfltOpt",17)==0) { id_SetEnum(parent,fasttest_TemplateHeader_id_fasttest_SeqTrvLenDfltOpt); ret = true; break; }
13192                    if (memcmp(rhs.elems+8,".SeqTrvLenNoneOpt",17)==0) { id_SetEnum(parent,fasttest_TemplateHeader_id_fasttest_SeqTrvLenNoneOpt); ret = true; break; }
13193                    break;
13194                }
13195            }
13196            break;
13197        }
13198        case 26: {
13199            switch (algo::ReadLE64(rhs.elems)) {
13200                case LE_STR8('f','a','s','t','t','e','s','t'): {
13201                    if (memcmp(rhs.elems+8,".SampleEnumDefault",18)==0) { id_SetEnum(parent,fasttest_TemplateHeader_id_fasttest_SampleEnumDefault); ret = true; break; }
13202                    if (memcmp(rhs.elems+8,".SeqTrvLenConstOpt",18)==0) { id_SetEnum(parent,fasttest_TemplateHeader_id_fasttest_SeqTrvLenConstOpt); ret = true; break; }
13203                    break;
13204                }
13205            }
13206            break;
13207        }
13208    }
13209    return ret;
13210}
13211
13212// --- fasttest.TemplateHeader.id.SetStrptr
13213// Convert string to field.
13214// If the string is invalid, set numeric value to DFLT
13215void fasttest::id_SetStrptr(fasttest::TemplateHeader& parent, algo::strptr rhs, fasttest_TemplateHeader_id_Enum dflt) {
13216    if (!id_SetStrptrMaybe(parent,rhs)) id_SetEnum(parent,dflt);
13217}
13218
13219// --- fasttest.TemplateHeader.id.ReadStrptrMaybe
13220// Convert string to field. Return success value
13221bool fasttest::id_ReadStrptrMaybe(fasttest::TemplateHeader& parent, algo::strptr rhs) {
13222    bool retval = false;
13223    retval = id_SetStrptrMaybe(parent,rhs); // try symbol conversion
13224    if (!retval) { // didn't work? try reading as underlying type
13225        retval = u32_ReadStrptrMaybe(parent.id,rhs);
13226    }
13227    return retval;
13228}
13229
13230// --- fasttest.TemplateHeader..ReadFieldMaybe
13231bool fasttest::TemplateHeader_ReadFieldMaybe(fasttest::TemplateHeader& parent, algo::strptr field, algo::strptr strval) {
13232    bool retval = true;
13233    fasttest::FieldId field_id;
13234    (void)value_SetStrptrMaybe(field_id,field);
13235    switch(field_id) {
13236        case fasttest_FieldId_length: {
13237            retval = false;
13238            break;
13239        }
13240        case fasttest_FieldId_id: {
13241            retval = id_ReadStrptrMaybe(parent, strval);
13242            break;
13243        }
13244        default: break;
13245    }
13246    if (!retval) {
13247        algo_lib::AppendErrtext("attr",field);
13248    }
13249    return retval;
13250}
13251
13252// --- fasttest.TemplateHeader..ReadStrptrMaybe
13253// Read fields of fasttest::TemplateHeader from an ascii string.
13254// The format of the string is an ssim Tuple
13255bool fasttest::TemplateHeader_ReadStrptrMaybe(fasttest::TemplateHeader &parent, algo::strptr in_str) {
13256    bool retval = true;
13257    retval = algo::StripTypeTag(in_str, "fasttest.TemplateHeader");
13258    ind_beg(algo::Attr_curs, attr, in_str) {
13259        retval = retval && TemplateHeader_ReadFieldMaybe(parent, attr.name, attr.value);
13260    }ind_end;
13261    return retval;
13262}
13263
13264// --- fasttest.TemplateHeader..Print
13265// print string representation of ROW to string STR
13266// cfmt:fasttest.TemplateHeader.String  printfmt:Tuple
13267void fasttest::TemplateHeader_Print(fasttest::TemplateHeader& row, algo::cstring& str) {
13268    algo::tempstr temp;
13269    str << "fasttest.TemplateHeader";
13270    (void)row;//only to avoid -Wunused-parameter
13271}
13272
13273// --- fasttest.TemplateHeaderMsgsCase.value.ToCstr
13274// Convert numeric value of field to one of predefined string constants.
13275// If string is found, return a static C string. Otherwise, return NULL.
13276const char* fasttest::value_ToCstr(const fasttest::TemplateHeaderMsgsCase& parent) {
13277    const char *ret = NULL;
13278    switch(value_GetEnum(parent)) {
13279        case fasttest_TemplateHeaderMsgsCase_fasttest_BVConst: ret = "fasttest.BVConst";  break;
13280        case fasttest_TemplateHeaderMsgsCase_fasttest_BVConstOpt: ret = "fasttest.BVConstOpt";  break;
13281        case fasttest_TemplateHeaderMsgsCase_fasttest_BVCopy: ret = "fasttest.BVCopy";  break;
13282        case fasttest_TemplateHeaderMsgsCase_fasttest_BVCopyNull: ret = "fasttest.BVCopyNull";  break;
13283        case fasttest_TemplateHeaderMsgsCase_fasttest_BVCopyOpt: ret = "fasttest.BVCopyOpt";  break;
13284        case fasttest_TemplateHeaderMsgsCase_fasttest_BVDflt: ret = "fasttest.BVDflt";  break;
13285        case fasttest_TemplateHeaderMsgsCase_fasttest_BVDfltNull: ret = "fasttest.BVDfltNull";  break;
13286        case fasttest_TemplateHeaderMsgsCase_fasttest_BVDfltOpt: ret = "fasttest.BVDfltOpt";  break;
13287        case fasttest_TemplateHeaderMsgsCase_fasttest_BVNone: ret = "fasttest.BVNone";  break;
13288        case fasttest_TemplateHeaderMsgsCase_fasttest_BVNoneOpt: ret = "fasttest.BVNoneOpt";  break;
13289        case fasttest_TemplateHeaderMsgsCase_fasttest_GroupSgmOpt: ret = "fasttest.GroupSgmOpt";  break;
13290        case fasttest_TemplateHeaderMsgsCase_fasttest_GroupTrv: ret = "fasttest.GroupTrv";  break;
13291        case fasttest_TemplateHeaderMsgsCase_fasttest_GroupTrvOpt: ret = "fasttest.GroupTrvOpt";  break;
13292        case fasttest_TemplateHeaderMsgsCase_fasttest_I32Const: ret = "fasttest.I32Const";  break;
13293        case fasttest_TemplateHeaderMsgsCase_fasttest_I32ConstOpt: ret = "fasttest.I32ConstOpt";  break;
13294        case fasttest_TemplateHeaderMsgsCase_fasttest_I32Copy: ret = "fasttest.I32Copy";  break;
13295        case fasttest_TemplateHeaderMsgsCase_fasttest_I32CopyNull: ret = "fasttest.I32CopyNull";  break;
13296        case fasttest_TemplateHeaderMsgsCase_fasttest_I32CopyOpt: ret = "fasttest.I32CopyOpt";  break;
13297        case fasttest_TemplateHeaderMsgsCase_fasttest_I32Delta: ret = "fasttest.I32Delta";  break;
13298        case fasttest_TemplateHeaderMsgsCase_fasttest_I32DeltaImpl: ret = "fasttest.I32DeltaImpl";  break;
13299        case fasttest_TemplateHeaderMsgsCase_fasttest_I32DeltaNull: ret = "fasttest.I32DeltaNull";  break;
13300        case fasttest_TemplateHeaderMsgsCase_fasttest_I32DeltaOpt: ret = "fasttest.I32DeltaOpt";  break;
13301        case fasttest_TemplateHeaderMsgsCase_fasttest_I32Dflt: ret = "fasttest.I32Dflt";  break;
13302        case fasttest_TemplateHeaderMsgsCase_fasttest_I32DfltNull: ret = "fasttest.I32DfltNull";  break;
13303        case fasttest_TemplateHeaderMsgsCase_fasttest_I32DfltOpt: ret = "fasttest.I32DfltOpt";  break;
13304        case fasttest_TemplateHeaderMsgsCase_fasttest_I32Incr: ret = "fasttest.I32Incr";  break;
13305        case fasttest_TemplateHeaderMsgsCase_fasttest_I32IncrNV: ret = "fasttest.I32IncrNV";  break;
13306        case fasttest_TemplateHeaderMsgsCase_fasttest_I32IncrNull: ret = "fasttest.I32IncrNull";  break;
13307        case fasttest_TemplateHeaderMsgsCase_fasttest_I32IncrOpt: ret = "fasttest.I32IncrOpt";  break;
13308        case fasttest_TemplateHeaderMsgsCase_fasttest_I32None: ret = "fasttest.I32None";  break;
13309        case fasttest_TemplateHeaderMsgsCase_fasttest_I32NoneOpt: ret = "fasttest.I32NoneOpt";  break;
13310        case fasttest_TemplateHeaderMsgsCase_fasttest_MsgPmap: ret = "fasttest.MsgPmap";  break;
13311        case fasttest_TemplateHeaderMsgsCase_fasttest_Reset: ret = "fasttest.Reset";  break;
13312        case fasttest_TemplateHeaderMsgsCase_fasttest_SampleEnumConst: ret = "fasttest.SampleEnumConst";  break;
13313        case fasttest_TemplateHeaderMsgsCase_fasttest_SampleEnumCopy: ret = "fasttest.SampleEnumCopy";  break;
13314        case fasttest_TemplateHeaderMsgsCase_fasttest_SampleEnumDefault: ret = "fasttest.SampleEnumDefault";  break;
13315        case fasttest_TemplateHeaderMsgsCase_fasttest_SampleSetConst: ret = "fasttest.SampleSetConst";  break;
13316        case fasttest_TemplateHeaderMsgsCase_fasttest_SampleSetCopy: ret = "fasttest.SampleSetCopy";  break;
13317        case fasttest_TemplateHeaderMsgsCase_fasttest_SampleSetDefault: ret = "fasttest.SampleSetDefault";  break;
13318        case fasttest_TemplateHeaderMsgsCase_fasttest_SclConst: ret = "fasttest.SclConst";  break;
13319        case fasttest_TemplateHeaderMsgsCase_fasttest_SclConstOpt: ret = "fasttest.SclConstOpt";  break;
13320        case fasttest_TemplateHeaderMsgsCase_fasttest_SclCopy: ret = "fasttest.SclCopy";  break;
13321        case fasttest_TemplateHeaderMsgsCase_fasttest_SclCopyNull: ret = "fasttest.SclCopyNull";  break;
13322        case fasttest_TemplateHeaderMsgsCase_fasttest_SclCopyOpt: ret = "fasttest.SclCopyOpt";  break;
13323        case fasttest_TemplateHeaderMsgsCase_fasttest_SclDelta: ret = "fasttest.SclDelta";  break;
13324        case fasttest_TemplateHeaderMsgsCase_fasttest_SclDeltaImpl: ret = "fasttest.SclDeltaImpl";  break;
13325        case fasttest_TemplateHeaderMsgsCase_fasttest_SclDeltaNull: ret = "fasttest.SclDeltaNull";  break;
13326        case fasttest_TemplateHeaderMsgsCase_fasttest_SclDeltaOpt: ret = "fasttest.SclDeltaOpt";  break;
13327        case fasttest_TemplateHeaderMsgsCase_fasttest_SclDflt: ret = "fasttest.SclDflt";  break;
13328        case fasttest_TemplateHeaderMsgsCase_fasttest_SclDfltNull: ret = "fasttest.SclDfltNull";  break;
13329        case fasttest_TemplateHeaderMsgsCase_fasttest_SclDfltOpt: ret = "fasttest.SclDfltOpt";  break;
13330        case fasttest_TemplateHeaderMsgsCase_fasttest_SclNone: ret = "fasttest.SclNone";  break;
13331        case fasttest_TemplateHeaderMsgsCase_fasttest_SclNoneOpt: ret = "fasttest.SclNoneOpt";  break;
13332        case fasttest_TemplateHeaderMsgsCase_fasttest_SeqOrder: ret = "fasttest.SeqOrder";  break;
13333        case fasttest_TemplateHeaderMsgsCase_fasttest_SeqSgmOpt: ret = "fasttest.SeqSgmOpt";  break;
13334        case fasttest_TemplateHeaderMsgsCase_fasttest_SeqTrv: ret = "fasttest.SeqTrv";  break;
13335        case fasttest_TemplateHeaderMsgsCase_fasttest_SeqTrvLenConst: ret = "fasttest.SeqTrvLenConst";  break;
13336        case fasttest_TemplateHeaderMsgsCase_fasttest_SeqTrvLenConstOpt: ret = "fasttest.SeqTrvLenConstOpt";  break;
13337        case fasttest_TemplateHeaderMsgsCase_fasttest_SeqTrvLenDflt: ret = "fasttest.SeqTrvLenDflt";  break;
13338        case fasttest_TemplateHeaderMsgsCase_fasttest_SeqTrvLenDfltOpt: ret = "fasttest.SeqTrvLenDfltOpt";  break;
13339        case fasttest_TemplateHeaderMsgsCase_fasttest_SeqTrvLenNone: ret = "fasttest.SeqTrvLenNone";  break;
13340        case fasttest_TemplateHeaderMsgsCase_fasttest_SeqTrvLenNoneOpt: ret = "fasttest.SeqTrvLenNoneOpt";  break;
13341        case fasttest_TemplateHeaderMsgsCase_fasttest_SeqTrvOpt: ret = "fasttest.SeqTrvOpt";  break;
13342        case fasttest_TemplateHeaderMsgsCase_fasttest_StrConst: ret = "fasttest.StrConst";  break;
13343        case fasttest_TemplateHeaderMsgsCase_fasttest_StrConstOpt: ret = "fasttest.StrConstOpt";  break;
13344        case fasttest_TemplateHeaderMsgsCase_fasttest_StrCopy: ret = "fasttest.StrCopy";  break;
13345        case fasttest_TemplateHeaderMsgsCase_fasttest_StrCopyNull: ret = "fasttest.StrCopyNull";  break;
13346        case fasttest_TemplateHeaderMsgsCase_fasttest_StrCopyOpt: ret = "fasttest.StrCopyOpt";  break;
13347        case fasttest_TemplateHeaderMsgsCase_fasttest_StrDflt: ret = "fasttest.StrDflt";  break;
13348        case fasttest_TemplateHeaderMsgsCase_fasttest_StrDfltNull: ret = "fasttest.StrDfltNull";  break;
13349        case fasttest_TemplateHeaderMsgsCase_fasttest_StrDfltOpt: ret = "fasttest.StrDfltOpt";  break;
13350        case fasttest_TemplateHeaderMsgsCase_fasttest_StrNone: ret = "fasttest.StrNone";  break;
13351        case fasttest_TemplateHeaderMsgsCase_fasttest_StrNoneOpt: ret = "fasttest.StrNoneOpt";  break;
13352        case fasttest_TemplateHeaderMsgsCase_fasttest_U32Const: ret = "fasttest.U32Const";  break;
13353        case fasttest_TemplateHeaderMsgsCase_fasttest_U32ConstOpt: ret = "fasttest.U32ConstOpt";  break;
13354        case fasttest_TemplateHeaderMsgsCase_fasttest_U32Copy: ret = "fasttest.U32Copy";  break;
13355        case fasttest_TemplateHeaderMsgsCase_fasttest_U32CopyNull: ret = "fasttest.U32CopyNull";  break;
13356        case fasttest_TemplateHeaderMsgsCase_fasttest_U32CopyOpt: ret = "fasttest.U32CopyOpt";  break;
13357        case fasttest_TemplateHeaderMsgsCase_fasttest_U32Delta: ret = "fasttest.U32Delta";  break;
13358        case fasttest_TemplateHeaderMsgsCase_fasttest_U32DeltaImpl: ret = "fasttest.U32DeltaImpl";  break;
13359        case fasttest_TemplateHeaderMsgsCase_fasttest_U32DeltaNull: ret = "fasttest.U32DeltaNull";  break;
13360        case fasttest_TemplateHeaderMsgsCase_fasttest_U32DeltaOpt: ret = "fasttest.U32DeltaOpt";  break;
13361        case fasttest_TemplateHeaderMsgsCase_fasttest_U32Dflt: ret = "fasttest.U32Dflt";  break;
13362        case fasttest_TemplateHeaderMsgsCase_fasttest_U32DfltNull: ret = "fasttest.U32DfltNull";  break;
13363        case fasttest_TemplateHeaderMsgsCase_fasttest_U32DfltOpt: ret = "fasttest.U32DfltOpt";  break;
13364        case fasttest_TemplateHeaderMsgsCase_fasttest_U32Incr: ret = "fasttest.U32Incr";  break;
13365        case fasttest_TemplateHeaderMsgsCase_fasttest_U32IncrNV: ret = "fasttest.U32IncrNV";  break;
13366        case fasttest_TemplateHeaderMsgsCase_fasttest_U32IncrNull: ret = "fasttest.U32IncrNull";  break;
13367        case fasttest_TemplateHeaderMsgsCase_fasttest_U32IncrOpt: ret = "fasttest.U32IncrOpt";  break;
13368        case fasttest_TemplateHeaderMsgsCase_fasttest_U32None: ret = "fasttest.U32None";  break;
13369        case fasttest_TemplateHeaderMsgsCase_fasttest_U32NoneOpt: ret = "fasttest.U32NoneOpt";  break;
13370    }
13371    return ret;
13372}
13373
13374// --- fasttest.TemplateHeaderMsgsCase.value.Print
13375// Convert value to a string. First, attempt conversion to a known string.
13376// If no string matches, print value as a numeric value.
13377void fasttest::value_Print(const fasttest::TemplateHeaderMsgsCase& parent, algo::cstring &lhs) {
13378    const char *strval = value_ToCstr(parent);
13379    if (strval) {
13380        lhs << strval;
13381    } else {
13382        lhs << parent.value;
13383    }
13384}
13385
13386// --- fasttest.TemplateHeaderMsgsCase.value.SetStrptrMaybe
13387// Convert string to field.
13388// If the string is invalid, do not modify field and return false.
13389// In case of success, return true
13390bool fasttest::value_SetStrptrMaybe(fasttest::TemplateHeaderMsgsCase& parent, algo::strptr rhs) {
13391    bool ret = false;
13392    switch (elems_N(rhs)) {
13393        case 14: {
13394            switch (algo::ReadLE64(rhs.elems)) {
13395                case LE_STR8('f','a','s','t','t','e','s','t'): {
13396                    if (memcmp(rhs.elems+8,".Reset",6)==0) { value_SetEnum(parent,fasttest_TemplateHeaderMsgsCase_fasttest_Reset); ret = true; break; }
13397                    break;
13398                }
13399            }
13400            break;
13401        }
13402        case 15: {
13403            switch (algo::ReadLE64(rhs.elems)) {
13404                case LE_STR8('f','a','s','t','t','e','s','t'): {
13405                    if (memcmp(rhs.elems+8,".BVCopy",7)==0) { value_SetEnum(parent,fasttest_TemplateHeaderMsgsCase_fasttest_BVCopy); ret = true; break; }
13406                    if (memcmp(rhs.elems+8,".BVDflt",7)==0) { value_SetEnum(parent,fasttest_TemplateHeaderMsgsCase_fasttest_BVDflt); ret = true; break; }
13407                    if (memcmp(rhs.elems+8,".BVNone",7)==0) { value_SetEnum(parent,fasttest_TemplateHeaderMsgsCase_fasttest_BVNone); ret = true; break; }
13408                    if (memcmp(rhs.elems+8,".SeqTrv",7)==0) { value_SetEnum(parent,fasttest_TemplateHeaderMsgsCase_fasttest_SeqTrv); ret = true; break; }
13409                    break;
13410                }
13411            }
13412            break;
13413        }
13414        case 16: {
13415            switch (algo::ReadLE64(rhs.elems)) {
13416                case LE_STR8('f','a','s','t','t','e','s','t'): {
13417                    if (memcmp(rhs.elems+8,".BVConst",8)==0) { value_SetEnum(parent,fasttest_TemplateHeaderMsgsCase_fasttest_BVConst); ret = true; break; }
13418                    if (memcmp(rhs.elems+8,".I32Copy",8)==0) { value_SetEnum(parent,fasttest_TemplateHeaderMsgsCase_fasttest_I32Copy); ret = true; break; }
13419                    if (memcmp(rhs.elems+8,".I32Dflt",8)==0) { value_SetEnum(parent,fasttest_TemplateHeaderMsgsCase_fasttest_I32Dflt); ret = true; break; }
13420                    if (memcmp(rhs.elems+8,".I32Incr",8)==0) { value_SetEnum(parent,fasttest_TemplateHeaderMsgsCase_fasttest_I32Incr); ret = true; break; }
13421                    if (memcmp(rhs.elems+8,".I32None",8)==0) { value_SetEnum(parent,fasttest_TemplateHeaderMsgsCase_fasttest_I32None); ret = true; break; }
13422                    if (memcmp(rhs.elems+8,".MsgPmap",8)==0) { value_SetEnum(parent,fasttest_TemplateHeaderMsgsCase_fasttest_MsgPmap); ret = true; break; }
13423                    if (memcmp(rhs.elems+8,".SclCopy",8)==0) { value_SetEnum(parent,fasttest_TemplateHeaderMsgsCase_fasttest_SclCopy); ret = true; break; }
13424                    if (memcmp(rhs.elems+8,".SclDflt",8)==0) { value_SetEnum(parent,fasttest_TemplateHeaderMsgsCase_fasttest_SclDflt); ret = true; break; }
13425                    if (memcmp(rhs.elems+8,".SclNone",8)==0) { value_SetEnum(parent,fasttest_TemplateHeaderMsgsCase_fasttest_SclNone); ret = true; break; }
13426                    if (memcmp(rhs.elems+8,".StrCopy",8)==0) { value_SetEnum(parent,fasttest_TemplateHeaderMsgsCase_fasttest_StrCopy); ret = true; break; }
13427                    if (memcmp(rhs.elems+8,".StrDflt",8)==0) { value_SetEnum(parent,fasttest_TemplateHeaderMsgsCase_fasttest_StrDflt); ret = true; break; }
13428                    if (memcmp(rhs.elems+8,".StrNone",8)==0) { value_SetEnum(parent,fasttest_TemplateHeaderMsgsCase_fasttest_StrNone); ret = true; break; }
13429                    if (memcmp(rhs.elems+8,".U32Copy",8)==0) { value_SetEnum(parent,fasttest_TemplateHeaderMsgsCase_fasttest_U32Copy); ret = true; break; }
13430                    if (memcmp(rhs.elems+8,".U32Dflt",8)==0) { value_SetEnum(parent,fasttest_TemplateHeaderMsgsCase_fasttest_U32Dflt); ret = true; break; }
13431                    if (memcmp(rhs.elems+8,".U32Incr",8)==0) { value_SetEnum(parent,fasttest_TemplateHeaderMsgsCase_fasttest_U32Incr); ret = true; break; }
13432                    if (memcmp(rhs.elems+8,".U32None",8)==0) { value_SetEnum(parent,fasttest_TemplateHeaderMsgsCase_fasttest_U32None); ret = true; break; }
13433                    break;
13434                }
13435            }
13436            break;
13437        }
13438        case 17: {
13439            switch (algo::ReadLE64(rhs.elems)) {
13440                case LE_STR8('f','a','s','t','t','e','s','t'): {
13441                    if (memcmp(rhs.elems+8,".GroupTrv",9)==0) { value_SetEnum(parent,fasttest_TemplateHeaderMsgsCase_fasttest_GroupTrv); ret = true; break; }
13442                    if (memcmp(rhs.elems+8,".I32Const",9)==0) { value_SetEnum(parent,fasttest_TemplateHeaderMsgsCase_fasttest_I32Const); ret = true; break; }
13443                    if (memcmp(rhs.elems+8,".I32Delta",9)==0) { value_SetEnum(parent,fasttest_TemplateHeaderMsgsCase_fasttest_I32Delta); ret = true; break; }
13444                    if (memcmp(rhs.elems+8,".SclConst",9)==0) { value_SetEnum(parent,fasttest_TemplateHeaderMsgsCase_fasttest_SclConst); ret = true; break; }
13445                    if (memcmp(rhs.elems+8,".SclDelta",9)==0) { value_SetEnum(parent,fasttest_TemplateHeaderMsgsCase_fasttest_SclDelta); ret = true; break; }
13446                    if (memcmp(rhs.elems+8,".SeqOrder",9)==0) { value_SetEnum(parent,fasttest_TemplateHeaderMsgsCase_fasttest_SeqOrder); ret = true; break; }
13447                    if (memcmp(rhs.elems+8,".StrConst",9)==0) { value_SetEnum(parent,fasttest_TemplateHeaderMsgsCase_fasttest_StrConst); ret = true; break; }
13448                    if (memcmp(rhs.elems+8,".U32Const",9)==0) { value_SetEnum(parent,fasttest_TemplateHeaderMsgsCase_fasttest_U32Const); ret = true; break; }
13449                    if (memcmp(rhs.elems+8,".U32Delta",9)==0) { value_SetEnum(parent,fasttest_TemplateHeaderMsgsCase_fasttest_U32Delta); ret = true; break; }
13450                    break;
13451                }
13452            }
13453            break;
13454        }
13455        case 18: {
13456            switch (algo::ReadLE64(rhs.elems)) {
13457                case LE_STR8('f','a','s','t','t','e','s','t'): {
13458                    if (memcmp(rhs.elems+8,".BVCopyOpt",10)==0) { value_SetEnum(parent,fasttest_TemplateHeaderMsgsCase_fasttest_BVCopyOpt); ret = true; break; }
13459                    if (memcmp(rhs.elems+8,".BVDfltOpt",10)==0) { value_SetEnum(parent,fasttest_TemplateHeaderMsgsCase_fasttest_BVDfltOpt); ret = true; break; }
13460                    if (memcmp(rhs.elems+8,".BVNoneOpt",10)==0) { value_SetEnum(parent,fasttest_TemplateHeaderMsgsCase_fasttest_BVNoneOpt); ret = true; break; }
13461                    if (memcmp(rhs.elems+8,".I32IncrNV",10)==0) { value_SetEnum(parent,fasttest_TemplateHeaderMsgsCase_fasttest_I32IncrNV); ret = true; break; }
13462                    if (memcmp(rhs.elems+8,".SeqSgmOpt",10)==0) { value_SetEnum(parent,fasttest_TemplateHeaderMsgsCase_fasttest_SeqSgmOpt); ret = true; break; }
13463                    if (memcmp(rhs.elems+8,".SeqTrvOpt",10)==0) { value_SetEnum(parent,fasttest_TemplateHeaderMsgsCase_fasttest_SeqTrvOpt); ret = true; break; }
13464                    if (memcmp(rhs.elems+8,".U32IncrNV",10)==0) { value_SetEnum(parent,fasttest_TemplateHeaderMsgsCase_fasttest_U32IncrNV); ret = true; break; }
13465                    break;
13466                }
13467            }
13468            break;
13469        }
13470        case 19: {
13471            switch (algo::ReadLE64(rhs.elems)) {
13472                case LE_STR8('f','a','s','t','t','e','s','t'): {
13473                    if (memcmp(rhs.elems+8,".BVConstOpt",11)==0) { value_SetEnum(parent,fasttest_TemplateHeaderMsgsCase_fasttest_BVConstOpt); ret = true; break; }
13474                    if (memcmp(rhs.elems+8,".BVCopyNull",11)==0) { value_SetEnum(parent,fasttest_TemplateHeaderMsgsCase_fasttest_BVCopyNull); ret = true; break; }
13475                    if (memcmp(rhs.elems+8,".BVDfltNull",11)==0) { value_SetEnum(parent,fasttest_TemplateHeaderMsgsCase_fasttest_BVDfltNull); ret = true; break; }
13476                    if (memcmp(rhs.elems+8,".I32CopyOpt",11)==0) { value_SetEnum(parent,fasttest_TemplateHeaderMsgsCase_fasttest_I32CopyOpt); ret = true; break; }
13477                    if (memcmp(rhs.elems+8,".I32DfltOpt",11)==0) { value_SetEnum(parent,fasttest_TemplateHeaderMsgsCase_fasttest_I32DfltOpt); ret = true; break; }
13478                    if (memcmp(rhs.elems+8,".I32IncrOpt",11)==0) { value_SetEnum(parent,fasttest_TemplateHeaderMsgsCase_fasttest_I32IncrOpt); ret = true; break; }
13479                    if (memcmp(rhs.elems+8,".I32NoneOpt",11)==0) { value_SetEnum(parent,fasttest_TemplateHeaderMsgsCase_fasttest_I32NoneOpt); ret = true; break; }
13480                    if (memcmp(rhs.elems+8,".SclCopyOpt",11)==0) { value_SetEnum(parent,fasttest_TemplateHeaderMsgsCase_fasttest_SclCopyOpt); ret = true; break; }
13481                    if (memcmp(rhs.elems+8,".SclDfltOpt",11)==0) { value_SetEnum(parent,fasttest_TemplateHeaderMsgsCase_fasttest_SclDfltOpt); ret = true; break; }
13482                    if (memcmp(rhs.elems+8,".SclNoneOpt",11)==0) { value_SetEnum(parent,fasttest_TemplateHeaderMsgsCase_fasttest_SclNoneOpt); ret = true; break; }
13483                    if (memcmp(rhs.elems+8,".StrCopyOpt",11)==0) { value_SetEnum(parent,fasttest_TemplateHeaderMsgsCase_fasttest_StrCopyOpt); ret = true; break; }
13484                    if (memcmp(rhs.elems+8,".StrDfltOpt",11)==0) { value_SetEnum(parent,fasttest_TemplateHeaderMsgsCase_fasttest_StrDfltOpt); ret = true; break; }
13485                    if (memcmp(rhs.elems+8,".StrNoneOpt",11)==0) { value_SetEnum(parent,fasttest_TemplateHeaderMsgsCase_fasttest_StrNoneOpt); ret = true; break; }
13486                    if (memcmp(rhs.elems+8,".U32CopyOpt",11)==0) { value_SetEnum(parent,fasttest_TemplateHeaderMsgsCase_fasttest_U32CopyOpt); ret = true; break; }
13487                    if (memcmp(rhs.elems+8,".U32DfltOpt",11)==0) { value_SetEnum(parent,fasttest_TemplateHeaderMsgsCase_fasttest_U32DfltOpt); ret = true; break; }
13488                    if (memcmp(rhs.elems+8,".U32IncrOpt",11)==0) { value_SetEnum(parent,fasttest_TemplateHeaderMsgsCase_fasttest_U32IncrOpt); ret = true; break; }
13489                    if (memcmp(rhs.elems+8,".U32NoneOpt",11)==0) { value_SetEnum(parent,fasttest_TemplateHeaderMsgsCase_fasttest_U32NoneOpt); ret = true; break; }
13490                    break;
13491                }
13492            }
13493            break;
13494        }
13495        case 20: {
13496            switch (algo::ReadLE64(rhs.elems)) {
13497                case LE_STR8('f','a','s','t','t','e','s','t'): {
13498                    if (memcmp(rhs.elems+8,".GroupSgmOpt",12)==0) { value_SetEnum(parent,fasttest_TemplateHeaderMsgsCase_fasttest_GroupSgmOpt); ret = true; break; }
13499                    if (memcmp(rhs.elems+8,".GroupTrvOpt",12)==0) { value_SetEnum(parent,fasttest_TemplateHeaderMsgsCase_fasttest_GroupTrvOpt); ret = true; break; }
13500                    if (memcmp(rhs.elems+8,".I32ConstOpt",12)==0) { value_SetEnum(parent,fasttest_TemplateHeaderMsgsCase_fasttest_I32ConstOpt); ret = true; break; }
13501                    if (memcmp(rhs.elems+8,".I32CopyNull",12)==0) { value_SetEnum(parent,fasttest_TemplateHeaderMsgsCase_fasttest_I32CopyNull); ret = true; break; }
13502                    if (memcmp(rhs.elems+8,".I32DeltaOpt",12)==0) { value_SetEnum(parent,fasttest_TemplateHeaderMsgsCase_fasttest_I32DeltaOpt); ret = true; break; }
13503                    if (memcmp(rhs.elems+8,".I32DfltNull",12)==0) { value_SetEnum(parent,fasttest_TemplateHeaderMsgsCase_fasttest_I32DfltNull); ret = true; break; }
13504                    if (memcmp(rhs.elems+8,".I32IncrNull",12)==0) { value_SetEnum(parent,fasttest_TemplateHeaderMsgsCase_fasttest_I32IncrNull); ret = true; break; }
13505                    if (memcmp(rhs.elems+8,".SclConstOpt",12)==0) { value_SetEnum(parent,fasttest_TemplateHeaderMsgsCase_fasttest_SclConstOpt); ret = true; break; }
13506                    if (memcmp(rhs.elems+8,".SclCopyNull",12)==0) { value_SetEnum(parent,fasttest_TemplateHeaderMsgsCase_fasttest_SclCopyNull); ret = true; break; }
13507                    if (memcmp(rhs.elems+8,".SclDeltaOpt",12)==0) { value_SetEnum(parent,fasttest_TemplateHeaderMsgsCase_fasttest_SclDeltaOpt); ret = true; break; }
13508                    if (memcmp(rhs.elems+8,".SclDfltNull",12)==0) { value_SetEnum(parent,fasttest_TemplateHeaderMsgsCase_fasttest_SclDfltNull); ret = true; break; }
13509                    if (memcmp(rhs.elems+8,".StrConstOpt",12)==0) { value_SetEnum(parent,fasttest_TemplateHeaderMsgsCase_fasttest_StrConstOpt); ret = true; break; }
13510                    if (memcmp(rhs.elems+8,".StrCopyNull",12)==0) { value_SetEnum(parent,fasttest_TemplateHeaderMsgsCase_fasttest_StrCopyNull); ret = true; break; }
13511                    if (memcmp(rhs.elems+8,".StrDfltNull",12)==0) { value_SetEnum(parent,fasttest_TemplateHeaderMsgsCase_fasttest_StrDfltNull); ret = true; break; }
13512                    if (memcmp(rhs.elems+8,".U32ConstOpt",12)==0) { value_SetEnum(parent,fasttest_TemplateHeaderMsgsCase_fasttest_U32ConstOpt); ret = true; break; }
13513                    if (memcmp(rhs.elems+8,".U32CopyNull",12)==0) { value_SetEnum(parent,fasttest_TemplateHeaderMsgsCase_fasttest_U32CopyNull); ret = true; break; }
13514                    if (memcmp(rhs.elems+8,".U32DeltaOpt",12)==0) { value_SetEnum(parent,fasttest_TemplateHeaderMsgsCase_fasttest_U32DeltaOpt); ret = true; break; }
13515                    if (memcmp(rhs.elems+8,".U32DfltNull",12)==0) { value_SetEnum(parent,fasttest_TemplateHeaderMsgsCase_fasttest_U32DfltNull); ret = true; break; }
13516                    if (memcmp(rhs.elems+8,".U32IncrNull",12)==0) { value_SetEnum(parent,fasttest_TemplateHeaderMsgsCase_fasttest_U32IncrNull); ret = true; break; }
13517                    break;
13518                }
13519            }
13520            break;
13521        }
13522        case 21: {
13523            switch (algo::ReadLE64(rhs.elems)) {
13524                case LE_STR8('f','a','s','t','t','e','s','t'): {
13525                    if (memcmp(rhs.elems+8,".I32DeltaImpl",13)==0) { value_SetEnum(parent,fasttest_TemplateHeaderMsgsCase_fasttest_I32DeltaImpl); ret = true; break; }
13526                    if (memcmp(rhs.elems+8,".I32DeltaNull",13)==0) { value_SetEnum(parent,fasttest_TemplateHeaderMsgsCase_fasttest_I32DeltaNull); ret = true; break; }
13527                    if (memcmp(rhs.elems+8,".SclDeltaImpl",13)==0) { value_SetEnum(parent,fasttest_TemplateHeaderMsgsCase_fasttest_SclDeltaImpl); ret = true; break; }
13528                    if (memcmp(rhs.elems+8,".SclDeltaNull",13)==0) { value_SetEnum(parent,fasttest_TemplateHeaderMsgsCase_fasttest_SclDeltaNull); ret = true; break; }
13529                    if (memcmp(rhs.elems+8,".U32DeltaImpl",13)==0) { value_SetEnum(parent,fasttest_TemplateHeaderMsgsCase_fasttest_U32DeltaImpl); ret = true; break; }
13530                    if (memcmp(rhs.elems+8,".U32DeltaNull",13)==0) { value_SetEnum(parent,fasttest_TemplateHeaderMsgsCase_fasttest_U32DeltaNull); ret = true; break; }
13531                    break;
13532                }
13533            }
13534            break;
13535        }
13536        case 22: {
13537            switch (algo::ReadLE64(rhs.elems)) {
13538                case LE_STR8('f','a','s','t','t','e','s','t'): {
13539                    if (memcmp(rhs.elems+8,".SampleSetCopy",14)==0) { value_SetEnum(parent,fasttest_TemplateHeaderMsgsCase_fasttest_SampleSetCopy); ret = true; break; }
13540                    if (memcmp(rhs.elems+8,".SeqTrvLenDflt",14)==0) { value_SetEnum(parent,fasttest_TemplateHeaderMsgsCase_fasttest_SeqTrvLenDflt); ret = true; break; }
13541                    if (memcmp(rhs.elems+8,".SeqTrvLenNone",14)==0) { value_SetEnum(parent,fasttest_TemplateHeaderMsgsCase_fasttest_SeqTrvLenNone); ret = true; break; }
13542                    break;
13543                }
13544            }
13545            break;
13546        }
13547        case 23: {
13548            switch (algo::ReadLE64(rhs.elems)) {
13549                case LE_STR8('f','a','s','t','t','e','s','t'): {
13550                    if (memcmp(rhs.elems+8,".SampleEnumCopy",15)==0) { value_SetEnum(parent,fasttest_TemplateHeaderMsgsCase_fasttest_SampleEnumCopy); ret = true; break; }
13551                    if (memcmp(rhs.elems+8,".SampleSetConst",15)==0) { value_SetEnum(parent,fasttest_TemplateHeaderMsgsCase_fasttest_SampleSetConst); ret = true; break; }
13552                    if (memcmp(rhs.elems+8,".SeqTrvLenConst",15)==0) { value_SetEnum(parent,fasttest_TemplateHeaderMsgsCase_fasttest_SeqTrvLenConst); ret = true; break; }
13553                    break;
13554                }
13555            }
13556            break;
13557        }
13558        case 24: {
13559            switch (algo::ReadLE64(rhs.elems)) {
13560                case LE_STR8('f','a','s','t','t','e','s','t'): {
13561                    if (memcmp(rhs.elems+8,".SampleEnumConst",16)==0) { value_SetEnum(parent,fasttest_TemplateHeaderMsgsCase_fasttest_SampleEnumConst); ret = true; break; }
13562                    break;
13563                }
13564            }
13565            break;
13566        }
13567        case 25: {
13568            switch (algo::ReadLE64(rhs.elems)) {
13569                case LE_STR8('f','a','s','t','t','e','s','t'): {
13570                    if (memcmp(rhs.elems+8,".SampleSetDefault",17)==0) { value_SetEnum(parent,fasttest_TemplateHeaderMsgsCase_fasttest_SampleSetDefault); ret = true; break; }
13571                    if (memcmp(rhs.elems+8,".SeqTrvLenDfltOpt",17)==0) { value_SetEnum(parent,fasttest_TemplateHeaderMsgsCase_fasttest_SeqTrvLenDfltOpt); ret = true; break; }
13572                    if (memcmp(rhs.elems+8,".SeqTrvLenNoneOpt",17)==0) { value_SetEnum(parent,fasttest_TemplateHeaderMsgsCase_fasttest_SeqTrvLenNoneOpt); ret = true; break; }
13573                    break;
13574                }
13575            }
13576            break;
13577        }
13578        case 26: {
13579            switch (algo::ReadLE64(rhs.elems)) {
13580                case LE_STR8('f','a','s','t','t','e','s','t'): {
13581                    if (memcmp(rhs.elems+8,".SampleEnumDefault",18)==0) { value_SetEnum(parent,fasttest_TemplateHeaderMsgsCase_fasttest_SampleEnumDefault); ret = true; break; }
13582                    if (memcmp(rhs.elems+8,".SeqTrvLenConstOpt",18)==0) { value_SetEnum(parent,fasttest_TemplateHeaderMsgsCase_fasttest_SeqTrvLenConstOpt); ret = true; break; }
13583                    break;
13584                }
13585            }
13586            break;
13587        }
13588    }
13589    return ret;
13590}
13591
13592// --- fasttest.TemplateHeaderMsgsCase.value.SetStrptr
13593// Convert string to field.
13594// If the string is invalid, set numeric value to DFLT
13595void fasttest::value_SetStrptr(fasttest::TemplateHeaderMsgsCase& parent, algo::strptr rhs, fasttest_TemplateHeaderMsgsCaseEnum dflt) {
13596    if (!value_SetStrptrMaybe(parent,rhs)) value_SetEnum(parent,dflt);
13597}
13598
13599// --- fasttest.TemplateHeaderMsgsCase.value.ReadStrptrMaybe
13600// Convert string to field. Return success value
13601bool fasttest::value_ReadStrptrMaybe(fasttest::TemplateHeaderMsgsCase& parent, algo::strptr rhs) {
13602    bool retval = false;
13603    retval = value_SetStrptrMaybe(parent,rhs); // try symbol conversion
13604    if (!retval) { // didn't work? try reading as underlying type
13605        retval = u32_ReadStrptrMaybe(parent.value,rhs);
13606    }
13607    return retval;
13608}
13609
13610// --- fasttest.TemplateHeaderMsgsCase..ReadStrptrMaybe
13611// Read fields of fasttest::TemplateHeaderMsgsCase from an ascii string.
13612// The format of the string is the format of the fasttest::TemplateHeaderMsgsCase's only field
13613bool fasttest::TemplateHeaderMsgsCase_ReadStrptrMaybe(fasttest::TemplateHeaderMsgsCase &parent, algo::strptr in_str) {
13614    bool retval = true;
13615    retval = retval && value_ReadStrptrMaybe(parent, in_str);
13616    return retval;
13617}
13618
13619// --- fasttest.U32Const.base.CopyOut
13620// Copy fields out of row
13621void fasttest::parent_CopyOut(fasttest::U32Const &row, fasttest::TemplateHeader &out) {
13622    // length: field value is computed
13623    // id: field value is computed
13624    (void)row;//only to avoid -Wunused-parameter
13625    (void)out;//only to avoid -Wunused-parameter
13626}
13627
13628// --- fasttest.U32Const..ReadFieldMaybe
13629bool fasttest::U32Const_ReadFieldMaybe(fasttest::U32Const& parent, algo::strptr field, algo::strptr strval) {
13630    bool retval = true;
13631    fasttest::FieldId field_id;
13632    (void)value_SetStrptrMaybe(field_id,field);
13633    switch(field_id) {
13634        case fasttest_FieldId_base: {
13635            retval = false;
13636            break;
13637        }
13638        case fasttest_FieldId_length: {
13639            retval = false;
13640            break;
13641        }
13642        case fasttest_FieldId_id: {
13643            retval = false;
13644            break;
13645        }
13646        case fasttest_FieldId_Value: {
13647            retval = true;
13648            break;
13649        }
13650        default: break;
13651    }
13652    if (!retval) {
13653        algo_lib::AppendErrtext("attr",field);
13654    }
13655    (void)parent;//only to avoid -Wunused-parameter
13656    (void)strval;//only to avoid -Wunused-parameter
13657    return retval;
13658}
13659
13660// --- fasttest.U32Const..ReadStrptrMaybe
13661// Read fields of fasttest::U32Const from an ascii string.
13662// The format of the string is an ssim Tuple
13663bool fasttest::U32Const_ReadStrptrMaybe(fasttest::U32Const &parent, algo::strptr in_str) {
13664    bool retval = true;
13665    retval = algo::StripTypeTag(in_str, "fasttest.U32Const");
13666    ind_beg(algo::Attr_curs, attr, in_str) {
13667        retval = retval && U32Const_ReadFieldMaybe(parent, attr.name, attr.value);
13668    }ind_end;
13669    return retval;
13670}
13671
13672// --- fasttest.U32Const..Print
13673// print string representation of ROW to string STR
13674// cfmt:fasttest.U32Const.String  printfmt:Tuple
13675void fasttest::U32Const_Print(fasttest::U32Const& row, algo::cstring& str) {
13676    algo::tempstr temp;
13677    str << "fasttest.U32Const";
13678
13679    u32_Print(Value_Get(row), temp);
13680    PrintAttrSpaceReset(str,"Value", temp);
13681}
13682
13683// --- fasttest.U32Const..FastEncode
13684void fasttest::U32Const_FastEncode(algo::ByteAry& buf, FastState& state, fasttest::U32Const& parent) {
13685    int index = ary_N(buf);
13686    u64 pmap(0);
13687    if (!tid_AssignedQ(state) || parent.id != state.tid) {
13688        lib_fast::EncodeUnsigned(buf,parent.id,false);
13689        lib_fast::SetPmapBit(pmap,0);
13690    }
13691    tid_SetAssigned(state);
13692    state.tid = parent.id;
13693    // Value unsigned constant mandatory
13694    lib_fast::InsertPmap(buf,index,pmap);
13695}
13696
13697// --- fasttest.U32Const..FastDecode
13698bool fasttest::U32Const_FastDecode(algo::memptr& from, u64 pmap, FastState& state, fasttest::U32Const& parent) {
13699    bool ok = true;
13700    // Value unsigned constant mandatory
13701    if (ok) {
13702    }
13703    (void)from;//only to avoid -Wunused-parameter
13704    (void)pmap;//only to avoid -Wunused-parameter
13705    (void)state;//only to avoid -Wunused-parameter
13706    (void)parent;//only to avoid -Wunused-parameter
13707    return ok;
13708}
13709
13710// --- fasttest.U32Const..FixEncode
13711void fasttest::U32Const_FixEncode(cstring& buf, fasttest::U32Const& parent, char soh) {
13712    buf << "1=" << Value_Get(parent) << soh;
13713}
13714
13715// --- fasttest.U32ConstOpt.base.CopyOut
13716// Copy fields out of row
13717void fasttest::parent_CopyOut(fasttest::U32ConstOpt &row, fasttest::TemplateHeader &out) {
13718    // length: field value is computed
13719    // id: field value is computed
13720    (void)row;//only to avoid -Wunused-parameter
13721    (void)out;//only to avoid -Wunused-parameter
13722}
13723
13724// --- fasttest.U32ConstOpt.pmask_bitcurs.Next
13725// proceed to next item
13726void fasttest::U32ConstOpt_pmask_bitcurs_Next(U32ConstOpt_pmask_bitcurs &curs) {
13727    ++curs.bit;
13728    int index = curs.bit / 32;
13729    int offset = curs.bit % 32;
13730    for (; index < curs.n_elems; ++index, offset = 0) {
13731        u64 rest = curs.elems[index] >> offset;
13732        if (rest) {
13733            offset += algo::u64_BitScanForward(rest);
13734            break;
13735        }
13736    }
13737    curs.bit = index * 32 + offset;
13738}
13739
13740// --- fasttest.U32ConstOpt..ReadFieldMaybe
13741bool fasttest::U32ConstOpt_ReadFieldMaybe(fasttest::U32ConstOpt& parent, algo::strptr field, algo::strptr strval) {
13742    bool retval = true;
13743    fasttest::FieldId field_id;
13744    (void)value_SetStrptrMaybe(field_id,field);
13745    switch(field_id) {
13746        case fasttest_FieldId_base: {
13747            retval = false;
13748            break;
13749        }
13750        case fasttest_FieldId_length: {
13751            retval = false;
13752            break;
13753        }
13754        case fasttest_FieldId_id: {
13755            retval = false;
13756            break;
13757        }
13758        case fasttest_FieldId_pmask: {
13759            retval = false;
13760            break;
13761        }
13762        case fasttest_FieldId_Value: {
13763            retval = true;
13764            if (retval) {
13765                pmask_qSetBit(parent, 0);
13766            }
13767            break;
13768        }
13769        default: break;
13770    }
13771    if (!retval) {
13772        algo_lib::AppendErrtext("attr",field);
13773    }
13774    (void)strval;//only to avoid -Wunused-parameter
13775    return retval;
13776}
13777
13778// --- fasttest.U32ConstOpt..ReadStrptrMaybe
13779// Read fields of fasttest::U32ConstOpt from an ascii string.
13780// The format of the string is an ssim Tuple
13781bool fasttest::U32ConstOpt_ReadStrptrMaybe(fasttest::U32ConstOpt &parent, algo::strptr in_str) {
13782    bool retval = true;
13783    retval = algo::StripTypeTag(in_str, "fasttest.U32ConstOpt");
13784    ind_beg(algo::Attr_curs, attr, in_str) {
13785        retval = retval && U32ConstOpt_ReadFieldMaybe(parent, attr.name, attr.value);
13786    }ind_end;
13787    return retval;
13788}
13789
13790// --- fasttest.U32ConstOpt..Print
13791// print string representation of ROW to string STR
13792// cfmt:fasttest.U32ConstOpt.String  printfmt:Tuple
13793void fasttest::U32ConstOpt_Print(fasttest::U32ConstOpt& row, algo::cstring& str) {
13794    algo::tempstr temp;
13795    str << "fasttest.U32ConstOpt";
13796
13797    if (Value_PresentQ(row)) {
13798        u32_Print(Value_Get(row), temp);
13799        PrintAttrSpaceReset(str,"Value", temp);
13800    }
13801}
13802
13803// --- fasttest.U32ConstOpt..FastEncode
13804void fasttest::U32ConstOpt_FastEncode(algo::ByteAry& buf, FastState& state, fasttest::U32ConstOpt& parent) {
13805    int index = ary_N(buf);
13806    u64 pmap(0);
13807    if (!tid_AssignedQ(state) || parent.id != state.tid) {
13808        lib_fast::EncodeUnsigned(buf,parent.id,false);
13809        lib_fast::SetPmapBit(pmap,0);
13810    }
13811    tid_SetAssigned(state);
13812    state.tid = parent.id;
13813    // Value unsigned constant optional
13814    if (Value_PresentQ(parent)) {
13815        lib_fast::SetPmapBit(pmap,1);
13816    }
13817    lib_fast::InsertPmap(buf,index,pmap);
13818}
13819
13820// --- fasttest.U32ConstOpt..FastDecode
13821bool fasttest::U32ConstOpt_FastDecode(algo::memptr& from, u64 pmap, FastState& state, fasttest::U32ConstOpt& parent) {
13822    bool ok = true;
13823    // Value unsigned constant optional
13824    if (ok) {
13825        bool prs = lib_fast::GetPmapBit(pmap,1);
13826        pmask_qSetBitVal(parent,Value_Present_GetBit(parent),prs);
13827    }
13828    (void)from;//only to avoid -Wunused-parameter
13829    (void)state;//only to avoid -Wunused-parameter
13830    return ok;
13831}
13832
13833// --- fasttest.U32ConstOpt..FixEncode
13834void fasttest::U32ConstOpt_FixEncode(cstring& buf, fasttest::U32ConstOpt& parent, char soh) {
13835    if (Value_PresentQ(parent)) {
13836        buf << "1=" << Value_Get(parent) << soh;
13837    }
13838}
13839
13840// --- fasttest.U32Copy.base.CopyOut
13841// Copy fields out of row
13842void fasttest::parent_CopyOut(fasttest::U32Copy &row, fasttest::TemplateHeader &out) {
13843    // length: field value is computed
13844    // id: field value is computed
13845    (void)row;//only to avoid -Wunused-parameter
13846    (void)out;//only to avoid -Wunused-parameter
13847}
13848
13849// --- fasttest.U32Copy..ReadFieldMaybe
13850bool fasttest::U32Copy_ReadFieldMaybe(fasttest::U32Copy& parent, algo::strptr field, algo::strptr strval) {
13851    bool retval = true;
13852    fasttest::FieldId field_id;
13853    (void)value_SetStrptrMaybe(field_id,field);
13854    switch(field_id) {
13855        case fasttest_FieldId_base: {
13856            retval = false;
13857            break;
13858        }
13859        case fasttest_FieldId_length: {
13860            retval = false;
13861            break;
13862        }
13863        case fasttest_FieldId_id: {
13864            retval = false;
13865            break;
13866        }
13867        case fasttest_FieldId_Value52: {
13868            retval = u32_ReadStrptrMaybe(parent.Value52, strval);
13869            break;
13870        }
13871        default: break;
13872    }
13873    if (!retval) {
13874        algo_lib::AppendErrtext("attr",field);
13875    }
13876    return retval;
13877}
13878
13879// --- fasttest.U32Copy..ReadStrptrMaybe
13880// Read fields of fasttest::U32Copy from an ascii string.
13881// The format of the string is an ssim Tuple
13882bool fasttest::U32Copy_ReadStrptrMaybe(fasttest::U32Copy &parent, algo::strptr in_str) {
13883    bool retval = true;
13884    retval = algo::StripTypeTag(in_str, "fasttest.U32Copy");
13885    ind_beg(algo::Attr_curs, attr, in_str) {
13886        retval = retval && U32Copy_ReadFieldMaybe(parent, attr.name, attr.value);
13887    }ind_end;
13888    return retval;
13889}
13890
13891// --- fasttest.U32Copy..Print
13892// print string representation of ROW to string STR
13893// cfmt:fasttest.U32Copy.String  printfmt:Tuple
13894void fasttest::U32Copy_Print(fasttest::U32Copy& row, algo::cstring& str) {
13895    algo::tempstr temp;
13896    str << "fasttest.U32Copy";
13897
13898    u32_Print(row.Value52, temp);
13899    PrintAttrSpaceReset(str,"Value52", temp);
13900}
13901
13902// --- fasttest.U32Copy..FastEncode
13903void fasttest::U32Copy_FastEncode(algo::ByteAry& buf, FastState& state, fasttest::U32Copy& parent) {
13904    int index = ary_N(buf);
13905    u64 pmap(0);
13906    if (!tid_AssignedQ(state) || parent.id != state.tid) {
13907        lib_fast::EncodeUnsigned(buf,parent.id,false);
13908        lib_fast::SetPmapBit(pmap,0);
13909    }
13910    tid_SetAssigned(state);
13911    state.tid = parent.id;
13912    // Value52 unsigned copy mandatory
13913    if (Value52_AssignedQ(state) ? parent.Value52 != state.Value52 : parent.Value52 != 52) {
13914        lib_fast::EncodeUnsigned(buf,parent.Value52,false);
13915        lib_fast::SetPmapBit(pmap,1);
13916    }
13917    state.Value52 = parent.Value52;
13918    Value52_SetAssigned(state);
13919    lib_fast::InsertPmap(buf,index,pmap);
13920}
13921
13922// --- fasttest.U32Copy..FastDecode
13923bool fasttest::U32Copy_FastDecode(algo::memptr& from, u64 pmap, FastState& state, fasttest::U32Copy& parent) {
13924    bool ok = true;
13925    // Value52 unsigned copy mandatory
13926    if (ok) {
13927        bool prs = lib_fast::GetPmapBit(pmap,1);
13928        if (prs) {
13929            ok = lib_fast::DecodeUnsigned(from,parent.Value52,false);
13930            if (!ok) {
13931                state.error << "fasttest.U32Copy.Value52: bad Unsigned" << eol;
13932            }
13933        } else if (Value52_AssignedQ(state)) {
13934            parent.Value52 = state.Value52;
13935        } else {
13936            parent.Value52 = 52;
13937        }
13938        Value52_SetAssigned(state);
13939        state.Value52 = parent.Value52;
13940    }
13941    return ok;
13942}
13943
13944// --- fasttest.U32Copy..FixEncode
13945void fasttest::U32Copy_FixEncode(cstring& buf, fasttest::U32Copy& parent, char soh) {
13946    buf << "1=" << parent.Value52 << soh;
13947}
13948
13949// --- fasttest.U32CopyNull.base.CopyOut
13950// Copy fields out of row
13951void fasttest::parent_CopyOut(fasttest::U32CopyNull &row, fasttest::TemplateHeader &out) {
13952    // length: field value is computed
13953    // id: field value is computed
13954    (void)row;//only to avoid -Wunused-parameter
13955    (void)out;//only to avoid -Wunused-parameter
13956}
13957
13958// --- fasttest.U32CopyNull.Value54.ReadStrptrMaybe
13959inline static bool fasttest::Value54_ReadStrptrMaybe(fasttest::U32CopyNull &parent, algo::strptr in_str) {
13960    bool retval = true;
13961    u32 Value54_tmp;
13962    retval = u32_ReadStrptrMaybe(Value54_tmp, in_str);
13963    if (retval) {
13964        Value54_Set(parent, Value54_tmp);
13965    }
13966    return retval;
13967}
13968
13969// --- fasttest.U32CopyNull.pmask_bitcurs.Next
13970// proceed to next item
13971void fasttest::U32CopyNull_pmask_bitcurs_Next(U32CopyNull_pmask_bitcurs &curs) {
13972    ++curs.bit;
13973    int index = curs.bit / 32;
13974    int offset = curs.bit % 32;
13975    for (; index < curs.n_elems; ++index, offset = 0) {
13976        u64 rest = curs.elems[index] >> offset;
13977        if (rest) {
13978            offset += algo::u64_BitScanForward(rest);
13979            break;
13980        }
13981    }
13982    curs.bit = index * 32 + offset;
13983}
13984
13985// --- fasttest.U32CopyNull..ReadFieldMaybe
13986bool fasttest::U32CopyNull_ReadFieldMaybe(fasttest::U32CopyNull& parent, algo::strptr field, algo::strptr strval) {
13987    bool retval = true;
13988    fasttest::FieldId field_id;
13989    (void)value_SetStrptrMaybe(field_id,field);
13990    switch(field_id) {
13991        case fasttest_FieldId_base: {
13992            retval = false;
13993            break;
13994        }
13995        case fasttest_FieldId_length: {
13996            retval = false;
13997            break;
13998        }
13999        case fasttest_FieldId_id: {
14000            retval = false;
14001            break;
14002        }
14003        case fasttest_FieldId_pmask: {
14004            retval = false;
14005            break;
14006        }
14007        case fasttest_FieldId_Value54: {
14008            retval = Value54_ReadStrptrMaybe(parent, strval);
14009            if (retval) {
14010                pmask_qSetBit(parent, 0);
14011            }
14012            break;
14013        }
14014        default: break;
14015    }
14016    if (!retval) {
14017        algo_lib::AppendErrtext("attr",field);
14018    }
14019    return retval;
14020}
14021
14022// --- fasttest.U32CopyNull..ReadStrptrMaybe
14023// Read fields of fasttest::U32CopyNull from an ascii string.
14024// The format of the string is an ssim Tuple
14025bool fasttest::U32CopyNull_ReadStrptrMaybe(fasttest::U32CopyNull &parent, algo::strptr in_str) {
14026    bool retval = true;
14027    retval = algo::StripTypeTag(in_str, "fasttest.U32CopyNull");
14028    ind_beg(algo::Attr_curs, attr, in_str) {
14029        retval = retval && U32CopyNull_ReadFieldMaybe(parent, attr.name, attr.value);
14030    }ind_end;
14031    return retval;
14032}
14033
14034// --- fasttest.U32CopyNull..Print
14035// print string representation of ROW to string STR
14036// cfmt:fasttest.U32CopyNull.String  printfmt:Tuple
14037void fasttest::U32CopyNull_Print(fasttest::U32CopyNull& row, algo::cstring& str) {
14038    algo::tempstr temp;
14039    str << "fasttest.U32CopyNull";
14040
14041    if (Value54_PresentQ(row)) {
14042        u32_Print(row.Value54, temp);
14043        PrintAttrSpaceReset(str,"Value54", temp);
14044    }
14045}
14046
14047// --- fasttest.U32CopyNull..FastEncode
14048void fasttest::U32CopyNull_FastEncode(algo::ByteAry& buf, FastState& state, fasttest::U32CopyNull& parent) {
14049    int index = ary_N(buf);
14050    u64 pmap(0);
14051    if (!tid_AssignedQ(state) || parent.id != state.tid) {
14052        lib_fast::EncodeUnsigned(buf,parent.id,false);
14053        lib_fast::SetPmapBit(pmap,0);
14054    }
14055    tid_SetAssigned(state);
14056    state.tid = parent.id;
14057    // Value54 unsigned copy optional
14058    if (Value54_PresentQ(parent)) {
14059        if (!Value54_AssignedQ(state) || !Value54_PresentQ(state) ||  parent.Value54 != state.Value54 ) {
14060            lib_fast::EncodeUnsigned(buf,parent.Value54,true);
14061            lib_fast::SetPmapBit(pmap,1);
14062        }
14063    } else {
14064        if (Value54_AssignedQ(state)) {
14065            lib_fast::EncodeNull(buf);
14066            lib_fast::SetPmapBit(pmap,1);
14067        }
14068    }
14069    state.Value54 = parent.Value54;
14070    present_qSetBitVal(state,Value54_Present_GetBit(state),Value54_PresentQ(parent));
14071    Value54_SetAssigned(state);
14072    lib_fast::InsertPmap(buf,index,pmap);
14073}
14074
14075// --- fasttest.U32CopyNull..FastDecode
14076bool fasttest::U32CopyNull_FastDecode(algo::memptr& from, u64 pmap, FastState& state, fasttest::U32CopyNull& parent) {
14077    bool ok = true;
14078    // Value54 unsigned copy optional
14079    if (ok) {
14080        bool prs = lib_fast::GetPmapBit(pmap,1);
14081        if (prs) {
14082            prs = !lib_fast::DecodeNull(from);
14083            if (prs) {
14084                ok = lib_fast::DecodeUnsigned(from,parent.Value54,true);
14085                if (!ok) {
14086                    state.error << "fasttest.U32CopyNull.Value54: bad Unsigned" << eol;
14087                }
14088            }
14089        } else if (Value54_AssignedQ(state)) {
14090            parent.Value54 = state.Value54;
14091            prs = Value54_PresentQ(state);
14092        } else {
14093            prs = false;
14094        }
14095        pmask_qSetBitVal(parent,Value54_Present_GetBit(parent),prs);
14096        Value54_SetAssigned(state);
14097        present_qSetBitVal(state,Value54_Present_GetBit(state),prs);
14098        state.Value54 = parent.Value54;
14099    }
14100    return ok;
14101}
14102
14103// --- fasttest.U32CopyNull..FixEncode
14104void fasttest::U32CopyNull_FixEncode(cstring& buf, fasttest::U32CopyNull& parent, char soh) {
14105    if (Value54_PresentQ(parent)) {
14106        buf << "1=" << parent.Value54 << soh;
14107    }
14108}
14109
14110// --- fasttest.U32CopyOpt.base.CopyOut
14111// Copy fields out of row
14112void fasttest::parent_CopyOut(fasttest::U32CopyOpt &row, fasttest::TemplateHeader &out) {
14113    // length: field value is computed
14114    // id: field value is computed
14115    (void)row;//only to avoid -Wunused-parameter
14116    (void)out;//only to avoid -Wunused-parameter
14117}
14118
14119// --- fasttest.U32CopyOpt.Value53.ReadStrptrMaybe
14120inline static bool fasttest::Value53_ReadStrptrMaybe(fasttest::U32CopyOpt &parent, algo::strptr in_str) {
14121    bool retval = true;
14122    u32 Value53_tmp;
14123    retval = u32_ReadStrptrMaybe(Value53_tmp, in_str);
14124    if (retval) {
14125        Value53_Set(parent, Value53_tmp);
14126    }
14127    return retval;
14128}
14129
14130// --- fasttest.U32CopyOpt.pmask_bitcurs.Next
14131// proceed to next item
14132void fasttest::U32CopyOpt_pmask_bitcurs_Next(U32CopyOpt_pmask_bitcurs &curs) {
14133    ++curs.bit;
14134    int index = curs.bit / 32;
14135    int offset = curs.bit % 32;
14136    for (; index < curs.n_elems; ++index, offset = 0) {
14137        u64 rest = curs.elems[index] >> offset;
14138        if (rest) {
14139            offset += algo::u64_BitScanForward(rest);
14140            break;
14141        }
14142    }
14143    curs.bit = index * 32 + offset;
14144}
14145
14146// --- fasttest.U32CopyOpt..ReadFieldMaybe
14147bool fasttest::U32CopyOpt_ReadFieldMaybe(fasttest::U32CopyOpt& parent, algo::strptr field, algo::strptr strval) {
14148    bool retval = true;
14149    fasttest::FieldId field_id;
14150    (void)value_SetStrptrMaybe(field_id,field);
14151    switch(field_id) {
14152        case fasttest_FieldId_base: {
14153            retval = false;
14154            break;
14155        }
14156        case fasttest_FieldId_length: {
14157            retval = false;
14158            break;
14159        }
14160        case fasttest_FieldId_id: {
14161            retval = false;
14162            break;
14163        }
14164        case fasttest_FieldId_pmask: {
14165            retval = false;
14166            break;
14167        }
14168        case fasttest_FieldId_Value53: {
14169            retval = Value53_ReadStrptrMaybe(parent, strval);
14170            if (retval) {
14171                pmask_qSetBit(parent, 0);
14172            }
14173            break;
14174        }
14175        default: break;
14176    }
14177    if (!retval) {
14178        algo_lib::AppendErrtext("attr",field);
14179    }
14180    return retval;
14181}
14182
14183// --- fasttest.U32CopyOpt..ReadStrptrMaybe
14184// Read fields of fasttest::U32CopyOpt from an ascii string.
14185// The format of the string is an ssim Tuple
14186bool fasttest::U32CopyOpt_ReadStrptrMaybe(fasttest::U32CopyOpt &parent, algo::strptr in_str) {
14187    bool retval = true;
14188    retval = algo::StripTypeTag(in_str, "fasttest.U32CopyOpt");
14189    ind_beg(algo::Attr_curs, attr, in_str) {
14190        retval = retval && U32CopyOpt_ReadFieldMaybe(parent, attr.name, attr.value);
14191    }ind_end;
14192    return retval;
14193}
14194
14195// --- fasttest.U32CopyOpt..Print
14196// print string representation of ROW to string STR
14197// cfmt:fasttest.U32CopyOpt.String  printfmt:Tuple
14198void fasttest::U32CopyOpt_Print(fasttest::U32CopyOpt& row, algo::cstring& str) {
14199    algo::tempstr temp;
14200    str << "fasttest.U32CopyOpt";
14201
14202    if (Value53_PresentQ(row)) {
14203        u32_Print(row.Value53, temp);
14204        PrintAttrSpaceReset(str,"Value53", temp);
14205    }
14206}
14207
14208// --- fasttest.U32CopyOpt..FastEncode
14209void fasttest::U32CopyOpt_FastEncode(algo::ByteAry& buf, FastState& state, fasttest::U32CopyOpt& parent) {
14210    int index = ary_N(buf);
14211    u64 pmap(0);
14212    if (!tid_AssignedQ(state) || parent.id != state.tid) {
14213        lib_fast::EncodeUnsigned(buf,parent.id,false);
14214        lib_fast::SetPmapBit(pmap,0);
14215    }
14216    tid_SetAssigned(state);
14217    state.tid = parent.id;
14218    // Value53 unsigned copy optional
14219    if (Value53_PresentQ(parent)) {
14220        if (Value53_AssignedQ(state) ? !Value53_PresentQ(state) || parent.Value53 != state.Value53 : parent.Value53 != 53) {
14221            lib_fast::EncodeUnsigned(buf,parent.Value53,true);
14222            lib_fast::SetPmapBit(pmap,1);
14223        }
14224    } else {
14225        if (Value53_AssignedQ(state) && Value53_PresentQ(state)) {
14226            lib_fast::EncodeNull(buf);
14227            lib_fast::SetPmapBit(pmap,1);
14228        }
14229    }
14230    state.Value53 = parent.Value53;
14231    present_qSetBitVal(state,Value53_Present_GetBit(state),Value53_PresentQ(parent));
14232    Value53_SetAssigned(state);
14233    lib_fast::InsertPmap(buf,index,pmap);
14234}
14235
14236// --- fasttest.U32CopyOpt..FastDecode
14237bool fasttest::U32CopyOpt_FastDecode(algo::memptr& from, u64 pmap, FastState& state, fasttest::U32CopyOpt& parent) {
14238    bool ok = true;
14239    // Value53 unsigned copy optional
14240    if (ok) {
14241        bool prs = lib_fast::GetPmapBit(pmap,1);
14242        if (prs) {
14243            prs = !lib_fast::DecodeNull(from);
14244            if (prs) {
14245                ok = lib_fast::DecodeUnsigned(from,parent.Value53,true);
14246                if (!ok) {
14247                    state.error << "fasttest.U32CopyOpt.Value53: bad Unsigned" << eol;
14248                }
14249            }
14250        } else if (Value53_AssignedQ(state)) {
14251            parent.Value53 = state.Value53;
14252            prs = Value53_PresentQ(state);
14253        } else {
14254            parent.Value53 = 53;
14255            prs = true;
14256        }
14257        pmask_qSetBitVal(parent,Value53_Present_GetBit(parent),prs);
14258        Value53_SetAssigned(state);
14259        present_qSetBitVal(state,Value53_Present_GetBit(state),prs);
14260        state.Value53 = parent.Value53;
14261    }
14262    return ok;
14263}
14264
14265// --- fasttest.U32CopyOpt..FixEncode
14266void fasttest::U32CopyOpt_FixEncode(cstring& buf, fasttest::U32CopyOpt& parent, char soh) {
14267    if (Value53_PresentQ(parent)) {
14268        buf << "1=" << parent.Value53 << soh;
14269    }
14270}
14271
14272// --- fasttest.U32Delta.base.CopyOut
14273// Copy fields out of row
14274void fasttest::parent_CopyOut(fasttest::U32Delta &row, fasttest::TemplateHeader &out) {
14275    // length: field value is computed
14276    // id: field value is computed
14277    (void)row;//only to avoid -Wunused-parameter
14278    (void)out;//only to avoid -Wunused-parameter
14279}
14280
14281// --- fasttest.U32Delta..ReadFieldMaybe
14282bool fasttest::U32Delta_ReadFieldMaybe(fasttest::U32Delta& parent, algo::strptr field, algo::strptr strval) {
14283    bool retval = true;
14284    fasttest::FieldId field_id;
14285    (void)value_SetStrptrMaybe(field_id,field);
14286    switch(field_id) {
14287        case fasttest_FieldId_base: {
14288            retval = false;
14289            break;
14290        }
14291        case fasttest_FieldId_length: {
14292            retval = false;
14293            break;
14294        }
14295        case fasttest_FieldId_id: {
14296            retval = false;
14297            break;
14298        }
14299        case fasttest_FieldId_Value69: {
14300            retval = u32_ReadStrptrMaybe(parent.Value69, strval);
14301            break;
14302        }
14303        default: break;
14304    }
14305    if (!retval) {
14306        algo_lib::AppendErrtext("attr",field);
14307    }
14308    return retval;
14309}
14310
14311// --- fasttest.U32Delta..ReadStrptrMaybe
14312// Read fields of fasttest::U32Delta from an ascii string.
14313// The format of the string is an ssim Tuple
14314bool fasttest::U32Delta_ReadStrptrMaybe(fasttest::U32Delta &parent, algo::strptr in_str) {
14315    bool retval = true;
14316    retval = algo::StripTypeTag(in_str, "fasttest.U32Delta");
14317    ind_beg(algo::Attr_curs, attr, in_str) {
14318        retval = retval && U32Delta_ReadFieldMaybe(parent, attr.name, attr.value);
14319    }ind_end;
14320    return retval;
14321}
14322
14323// --- fasttest.U32Delta..Print
14324// print string representation of ROW to string STR
14325// cfmt:fasttest.U32Delta.String  printfmt:Tuple
14326void fasttest::U32Delta_Print(fasttest::U32Delta& row, algo::cstring& str) {
14327    algo::tempstr temp;
14328    str << "fasttest.U32Delta";
14329
14330    u32_Print(row.Value69, temp);
14331    PrintAttrSpaceReset(str,"Value69", temp);
14332}
14333
14334// --- fasttest.U32Delta..FastEncode
14335void fasttest::U32Delta_FastEncode(algo::ByteAry& buf, FastState& state, fasttest::U32Delta& parent) {
14336    int index = ary_N(buf);
14337    u64 pmap(0);
14338    if (!tid_AssignedQ(state) || parent.id != state.tid) {
14339        lib_fast::EncodeUnsigned(buf,parent.id,false);
14340        lib_fast::SetPmapBit(pmap,0);
14341    }
14342    tid_SetAssigned(state);
14343    state.tid = parent.id;
14344    // Value69 unsigned delta mandatory
14345    if (!Value69_AssignedQ(state)) {
14346        Value69_SetAssigned(state);
14347        state.Value69 = 69;
14348    }
14349    lib_fast::EncodeDeltaUnsigned(buf,state.Value69,parent.Value69,false);
14350    state.Value69 = parent.Value69;
14351    lib_fast::InsertPmap(buf,index,pmap);
14352}
14353
14354// --- fasttest.U32Delta..FastDecode
14355bool fasttest::U32Delta_FastDecode(algo::memptr& from, u64 pmap, FastState& state, fasttest::U32Delta& parent) {
14356    bool ok = true;
14357    // Value69 unsigned delta mandatory
14358    if (ok) {
14359        if (!Value69_AssignedQ(state)) {
14360            Value69_SetAssigned(state);
14361            state.Value69 = 69;
14362        }
14363        ok = lib_fast::DecodeDeltaUnsigned(from,state.Value69,parent.Value69,false);
14364        if (!ok) {
14365            state.error << "fasttest.U32Delta.Value69: bad Unsigned delta" << eol;
14366        }
14367        state.Value69 = parent.Value69;
14368    }
14369    (void)pmap;//only to avoid -Wunused-parameter
14370    return ok;
14371}
14372
14373// --- fasttest.U32Delta..FixEncode
14374void fasttest::U32Delta_FixEncode(cstring& buf, fasttest::U32Delta& parent, char soh) {
14375    buf << "1=" << parent.Value69 << soh;
14376}
14377
14378// --- fasttest.U32DeltaImpl.base.CopyOut
14379// Copy fields out of row
14380void fasttest::parent_CopyOut(fasttest::U32DeltaImpl &row, fasttest::TemplateHeader &out) {
14381    // length: field value is computed
14382    // id: field value is computed
14383    (void)row;//only to avoid -Wunused-parameter
14384    (void)out;//only to avoid -Wunused-parameter
14385}
14386
14387// --- fasttest.U32DeltaImpl..ReadFieldMaybe
14388bool fasttest::U32DeltaImpl_ReadFieldMaybe(fasttest::U32DeltaImpl& parent, algo::strptr field, algo::strptr strval) {
14389    bool retval = true;
14390    fasttest::FieldId field_id;
14391    (void)value_SetStrptrMaybe(field_id,field);
14392    switch(field_id) {
14393        case fasttest_FieldId_base: {
14394            retval = false;
14395            break;
14396        }
14397        case fasttest_FieldId_length: {
14398            retval = false;
14399            break;
14400        }
14401        case fasttest_FieldId_id: {
14402            retval = false;
14403            break;
14404        }
14405        case fasttest_FieldId_Value70: {
14406            retval = u32_ReadStrptrMaybe(parent.Value70, strval);
14407            break;
14408        }
14409        default: break;
14410    }
14411    if (!retval) {
14412        algo_lib::AppendErrtext("attr",field);
14413    }
14414    return retval;
14415}
14416
14417// --- fasttest.U32DeltaImpl..ReadStrptrMaybe
14418// Read fields of fasttest::U32DeltaImpl from an ascii string.
14419// The format of the string is an ssim Tuple
14420bool fasttest::U32DeltaImpl_ReadStrptrMaybe(fasttest::U32DeltaImpl &parent, algo::strptr in_str) {
14421    bool retval = true;
14422    retval = algo::StripTypeTag(in_str, "fasttest.U32DeltaImpl");
14423    ind_beg(algo::Attr_curs, attr, in_str) {
14424        retval = retval && U32DeltaImpl_ReadFieldMaybe(parent, attr.name, attr.value);
14425    }ind_end;
14426    return retval;
14427}
14428
14429// --- fasttest.U32DeltaImpl..Print
14430// print string representation of ROW to string STR
14431// cfmt:fasttest.U32DeltaImpl.String  printfmt:Tuple
14432void fasttest::U32DeltaImpl_Print(fasttest::U32DeltaImpl& row, algo::cstring& str) {
14433    algo::tempstr temp;
14434    str << "fasttest.U32DeltaImpl";
14435
14436    u32_Print(row.Value70, temp);
14437    PrintAttrSpaceReset(str,"Value70", temp);
14438}
14439
14440// --- fasttest.U32DeltaImpl..FastEncode
14441void fasttest::U32DeltaImpl_FastEncode(algo::ByteAry& buf, FastState& state, fasttest::U32DeltaImpl& parent) {
14442    int index = ary_N(buf);
14443    u64 pmap(0);
14444    if (!tid_AssignedQ(state) || parent.id != state.tid) {
14445        lib_fast::EncodeUnsigned(buf,parent.id,false);
14446        lib_fast::SetPmapBit(pmap,0);
14447    }
14448    tid_SetAssigned(state);
14449    state.tid = parent.id;
14450    // Value70 unsigned delta mandatory
14451    if (!Value70_AssignedQ(state)) {
14452        Value70_SetAssigned(state);
14453        state.Value70 = 0;
14454    }
14455    lib_fast::EncodeDeltaUnsigned(buf,state.Value70,parent.Value70,false);
14456    state.Value70 = parent.Value70;
14457    lib_fast::InsertPmap(buf,index,pmap);
14458}
14459
14460// --- fasttest.U32DeltaImpl..FastDecode
14461bool fasttest::U32DeltaImpl_FastDecode(algo::memptr& from, u64 pmap, FastState& state, fasttest::U32DeltaImpl& parent) {
14462    bool ok = true;
14463    // Value70 unsigned delta mandatory
14464    if (ok) {
14465        if (!Value70_AssignedQ(state)) {
14466            Value70_SetAssigned(state);
14467            state.Value70 = 0;
14468        }
14469        ok = lib_fast::DecodeDeltaUnsigned(from,state.Value70,parent.Value70,false);
14470        if (!ok) {
14471            state.error << "fasttest.U32DeltaImpl.Value70: bad Unsigned delta" << eol;
14472        }
14473        state.Value70 = parent.Value70;
14474    }
14475    (void)pmap;//only to avoid -Wunused-parameter
14476    return ok;
14477}
14478
14479// --- fasttest.U32DeltaImpl..FixEncode
14480void fasttest::U32DeltaImpl_FixEncode(cstring& buf, fasttest::U32DeltaImpl& parent, char soh) {
14481    buf << "1=" << parent.Value70 << soh;
14482}
14483
14484// --- fasttest.U32DeltaNull.base.CopyOut
14485// Copy fields out of row
14486void fasttest::parent_CopyOut(fasttest::U32DeltaNull &row, fasttest::TemplateHeader &out) {
14487    // length: field value is computed
14488    // id: field value is computed
14489    (void)row;//only to avoid -Wunused-parameter
14490    (void)out;//only to avoid -Wunused-parameter
14491}
14492
14493// --- fasttest.U32DeltaNull.Value72.ReadStrptrMaybe
14494inline static bool fasttest::Value72_ReadStrptrMaybe(fasttest::U32DeltaNull &parent, algo::strptr in_str) {
14495    bool retval = true;
14496    u32 Value72_tmp;
14497    retval = u32_ReadStrptrMaybe(Value72_tmp, in_str);
14498    if (retval) {
14499        Value72_Set(parent, Value72_tmp);
14500    }
14501    return retval;
14502}
14503
14504// --- fasttest.U32DeltaNull.pmask_bitcurs.Next
14505// proceed to next item
14506void fasttest::U32DeltaNull_pmask_bitcurs_Next(U32DeltaNull_pmask_bitcurs &curs) {
14507    ++curs.bit;
14508    int index = curs.bit / 32;
14509    int offset = curs.bit % 32;
14510    for (; index < curs.n_elems; ++index, offset = 0) {
14511        u64 rest = curs.elems[index] >> offset;
14512        if (rest) {
14513            offset += algo::u64_BitScanForward(rest);
14514            break;
14515        }
14516    }
14517    curs.bit = index * 32 + offset;
14518}
14519
14520// --- fasttest.U32DeltaNull..ReadFieldMaybe
14521bool fasttest::U32DeltaNull_ReadFieldMaybe(fasttest::U32DeltaNull& parent, algo::strptr field, algo::strptr strval) {
14522    bool retval = true;
14523    fasttest::FieldId field_id;
14524    (void)value_SetStrptrMaybe(field_id,field);
14525    switch(field_id) {
14526        case fasttest_FieldId_base: {
14527            retval = false;
14528            break;
14529        }
14530        case fasttest_FieldId_length: {
14531            retval = false;
14532            break;
14533        }
14534        case fasttest_FieldId_id: {
14535            retval = false;
14536            break;
14537        }
14538        case fasttest_FieldId_pmask: {
14539            retval = false;
14540            break;
14541        }
14542        case fasttest_FieldId_Value72: {
14543            retval = Value72_ReadStrptrMaybe(parent, strval);
14544            if (retval) {
14545                pmask_qSetBit(parent, 0);
14546            }
14547            break;
14548        }
14549        default: break;
14550    }
14551    if (!retval) {
14552        algo_lib::AppendErrtext("attr",field);
14553    }
14554    return retval;
14555}
14556
14557// --- fasttest.U32DeltaNull..ReadStrptrMaybe
14558// Read fields of fasttest::U32DeltaNull from an ascii string.
14559// The format of the string is an ssim Tuple
14560bool fasttest::U32DeltaNull_ReadStrptrMaybe(fasttest::U32DeltaNull &parent, algo::strptr in_str) {
14561    bool retval = true;
14562    retval = algo::StripTypeTag(in_str, "fasttest.U32DeltaNull");
14563    ind_beg(algo::Attr_curs, attr, in_str) {
14564        retval = retval && U32DeltaNull_ReadFieldMaybe(parent, attr.name, attr.value);
14565    }ind_end;
14566    return retval;
14567}
14568
14569// --- fasttest.U32DeltaNull..Print
14570// print string representation of ROW to string STR
14571// cfmt:fasttest.U32DeltaNull.String  printfmt:Tuple
14572void fasttest::U32DeltaNull_Print(fasttest::U32DeltaNull& row, algo::cstring& str) {
14573    algo::tempstr temp;
14574    str << "fasttest.U32DeltaNull";
14575
14576    if (Value72_PresentQ(row)) {
14577        u32_Print(row.Value72, temp);
14578        PrintAttrSpaceReset(str,"Value72", temp);
14579    }
14580}
14581
14582// --- fasttest.U32DeltaNull..FastEncode
14583void fasttest::U32DeltaNull_FastEncode(algo::ByteAry& buf, FastState& state, fasttest::U32DeltaNull& parent) {
14584    int index = ary_N(buf);
14585    u64 pmap(0);
14586    if (!tid_AssignedQ(state) || parent.id != state.tid) {
14587        lib_fast::EncodeUnsigned(buf,parent.id,false);
14588        lib_fast::SetPmapBit(pmap,0);
14589    }
14590    tid_SetAssigned(state);
14591    state.tid = parent.id;
14592    // Value72 unsigned delta optional
14593    if (!Value72_AssignedQ(state)) {
14594        Value72_SetAssigned(state);
14595        present_qSetBitVal(state,Value72_Present_GetBit(state),Value72_PresentQ(parent));
14596        state.Value72 = 0;
14597    }
14598    if (Value72_PresentQ(parent)) {
14599        if (!Value72_PresentQ(state)) {
14600            state.Value72 = 0;
14601        }
14602        lib_fast::EncodeDeltaUnsigned(buf,state.Value72,parent.Value72,true);
14603    } else {
14604        lib_fast::EncodeNull(buf);
14605    }
14606    state.Value72 = parent.Value72;
14607    present_qSetBitVal(state,Value72_Present_GetBit(state),Value72_PresentQ(parent));
14608    lib_fast::InsertPmap(buf,index,pmap);
14609}
14610
14611// --- fasttest.U32DeltaNull..FastDecode
14612bool fasttest::U32DeltaNull_FastDecode(algo::memptr& from, u64 pmap, FastState& state, fasttest::U32DeltaNull& parent) {
14613    bool ok = true;
14614    // Value72 unsigned delta optional
14615    if (ok) {
14616        if (!Value72_AssignedQ(state)) {
14617            Value72_SetAssigned(state);
14618            bool prs(true);
14619            present_qSetBitVal(state,Value72_Present_GetBit(state),prs);
14620            state.Value72 = 0;
14621        }
14622        bool prs = !lib_fast::DecodeNull(from);
14623        if (prs) {
14624            if (!Value72_PresentQ(state)) {
14625                state.Value72 = 0;
14626            }
14627            ok = lib_fast::DecodeDeltaUnsigned(from,state.Value72,parent.Value72,true);
14628            if (!ok) {
14629                state.error << "fasttest.U32DeltaNull.Value72: bad Unsigned delta" << eol;
14630            }
14631            state.Value72 = parent.Value72;
14632        }
14633        pmask_qSetBitVal(parent,Value72_Present_GetBit(parent),prs);
14634        present_qSetBitVal(state,Value72_Present_GetBit(state),prs);
14635    }
14636    (void)pmap;//only to avoid -Wunused-parameter
14637    return ok;
14638}
14639
14640// --- fasttest.U32DeltaNull..FixEncode
14641void fasttest::U32DeltaNull_FixEncode(cstring& buf, fasttest::U32DeltaNull& parent, char soh) {
14642    if (Value72_PresentQ(parent)) {
14643        buf << "1=" << parent.Value72 << soh;
14644    }
14645}
14646
14647// --- fasttest.U32DeltaOpt.base.CopyOut
14648// Copy fields out of row
14649void fasttest::parent_CopyOut(fasttest::U32DeltaOpt &row, fasttest::TemplateHeader &out) {
14650    // length: field value is computed
14651    // id: field value is computed
14652    (void)row;//only to avoid -Wunused-parameter
14653    (void)out;//only to avoid -Wunused-parameter
14654}
14655
14656// --- fasttest.U32DeltaOpt.Value71.ReadStrptrMaybe
14657inline static bool fasttest::Value71_ReadStrptrMaybe(fasttest::U32DeltaOpt &parent, algo::strptr in_str) {
14658    bool retval = true;
14659    u32 Value71_tmp;
14660    retval = u32_ReadStrptrMaybe(Value71_tmp, in_str);
14661    if (retval) {
14662        Value71_Set(parent, Value71_tmp);
14663    }
14664    return retval;
14665}
14666
14667// --- fasttest.U32DeltaOpt.pmask_bitcurs.Next
14668// proceed to next item
14669void fasttest::U32DeltaOpt_pmask_bitcurs_Next(U32DeltaOpt_pmask_bitcurs &curs) {
14670    ++curs.bit;
14671    int index = curs.bit / 32;
14672    int offset = curs.bit % 32;
14673    for (; index < curs.n_elems; ++index, offset = 0) {
14674        u64 rest = curs.elems[index] >> offset;
14675        if (rest) {
14676            offset += algo::u64_BitScanForward(rest);
14677            break;
14678        }
14679    }
14680    curs.bit = index * 32 + offset;
14681}
14682
14683// --- fasttest.U32DeltaOpt..ReadFieldMaybe
14684bool fasttest::U32DeltaOpt_ReadFieldMaybe(fasttest::U32DeltaOpt& parent, algo::strptr field, algo::strptr strval) {
14685    bool retval = true;
14686    fasttest::FieldId field_id;
14687    (void)value_SetStrptrMaybe(field_id,field);
14688    switch(field_id) {
14689        case fasttest_FieldId_base: {
14690            retval = false;
14691            break;
14692        }
14693        case fasttest_FieldId_length: {
14694            retval = false;
14695            break;
14696        }
14697        case fasttest_FieldId_id: {
14698            retval = false;
14699            break;
14700        }
14701        case fasttest_FieldId_pmask: {
14702            retval = false;
14703            break;
14704        }
14705        case fasttest_FieldId_Value71: {
14706            retval = Value71_ReadStrptrMaybe(parent, strval);
14707            if (retval) {
14708                pmask_qSetBit(parent, 0);
14709            }
14710            break;
14711        }
14712        default: break;
14713    }
14714    if (!retval) {
14715        algo_lib::AppendErrtext("attr",field);
14716    }
14717    return retval;
14718}
14719
14720// --- fasttest.U32DeltaOpt..ReadStrptrMaybe
14721// Read fields of fasttest::U32DeltaOpt from an ascii string.
14722// The format of the string is an ssim Tuple
14723bool fasttest::U32DeltaOpt_ReadStrptrMaybe(fasttest::U32DeltaOpt &parent, algo::strptr in_str) {
14724    bool retval = true;
14725    retval = algo::StripTypeTag(in_str, "fasttest.U32DeltaOpt");
14726    ind_beg(algo::Attr_curs, attr, in_str) {
14727        retval = retval && U32DeltaOpt_ReadFieldMaybe(parent, attr.name, attr.value);
14728    }ind_end;
14729    return retval;
14730}
14731
14732// --- fasttest.U32DeltaOpt..Print
14733// print string representation of ROW to string STR
14734// cfmt:fasttest.U32DeltaOpt.String  printfmt:Tuple
14735void fasttest::U32DeltaOpt_Print(fasttest::U32DeltaOpt& row, algo::cstring& str) {
14736    algo::tempstr temp;
14737    str << "fasttest.U32DeltaOpt";
14738
14739    if (Value71_PresentQ(row)) {
14740        u32_Print(row.Value71, temp);
14741        PrintAttrSpaceReset(str,"Value71", temp);
14742    }
14743}
14744
14745// --- fasttest.U32DeltaOpt..FastEncode
14746void fasttest::U32DeltaOpt_FastEncode(algo::ByteAry& buf, FastState& state, fasttest::U32DeltaOpt& parent) {
14747    int index = ary_N(buf);
14748    u64 pmap(0);
14749    if (!tid_AssignedQ(state) || parent.id != state.tid) {
14750        lib_fast::EncodeUnsigned(buf,parent.id,false);
14751        lib_fast::SetPmapBit(pmap,0);
14752    }
14753    tid_SetAssigned(state);
14754    state.tid = parent.id;
14755    // Value71 unsigned delta optional
14756    if (!Value71_AssignedQ(state)) {
14757        Value71_SetAssigned(state);
14758        present_qSetBitVal(state,Value71_Present_GetBit(state),Value71_PresentQ(parent));
14759        state.Value71 = 71;
14760    }
14761    if (Value71_PresentQ(parent)) {
14762        if (!Value71_PresentQ(state)) {
14763            state.Value71 = 71;
14764        }
14765        lib_fast::EncodeDeltaUnsigned(buf,state.Value71,parent.Value71,true);
14766    } else {
14767        lib_fast::EncodeNull(buf);
14768    }
14769    state.Value71 = parent.Value71;
14770    present_qSetBitVal(state,Value71_Present_GetBit(state),Value71_PresentQ(parent));
14771    lib_fast::InsertPmap(buf,index,pmap);
14772}
14773
14774// --- fasttest.U32DeltaOpt..FastDecode
14775bool fasttest::U32DeltaOpt_FastDecode(algo::memptr& from, u64 pmap, FastState& state, fasttest::U32DeltaOpt& parent) {
14776    bool ok = true;
14777    // Value71 unsigned delta optional
14778    if (ok) {
14779        if (!Value71_AssignedQ(state)) {
14780            Value71_SetAssigned(state);
14781            bool prs(true);
14782            present_qSetBitVal(state,Value71_Present_GetBit(state),prs);
14783            state.Value71 = 71;
14784        }
14785        bool prs = !lib_fast::DecodeNull(from);
14786        if (prs) {
14787            if (!Value71_PresentQ(state)) {
14788                state.Value71 = 71;
14789            }
14790            ok = lib_fast::DecodeDeltaUnsigned(from,state.Value71,parent.Value71,true);
14791            if (!ok) {
14792                state.error << "fasttest.U32DeltaOpt.Value71: bad Unsigned delta" << eol;
14793            }
14794            state.Value71 = parent.Value71;
14795        }
14796        pmask_qSetBitVal(parent,Value71_Present_GetBit(parent),prs);
14797        present_qSetBitVal(state,Value71_Present_GetBit(state),prs);
14798    }
14799    (void)pmap;//only to avoid -Wunused-parameter
14800    return ok;
14801}
14802
14803// --- fasttest.U32DeltaOpt..FixEncode
14804void fasttest::U32DeltaOpt_FixEncode(cstring& buf, fasttest::U32DeltaOpt& parent, char soh) {
14805    if (Value71_PresentQ(parent)) {
14806        buf << "1=" << parent.Value71 << soh;
14807    }
14808}
14809
14810// --- fasttest.U32Dflt.base.CopyOut
14811// Copy fields out of row
14812void fasttest::parent_CopyOut(fasttest::U32Dflt &row, fasttest::TemplateHeader &out) {
14813    // length: field value is computed
14814    // id: field value is computed
14815    (void)row;//only to avoid -Wunused-parameter
14816    (void)out;//only to avoid -Wunused-parameter
14817}
14818
14819// --- fasttest.U32Dflt..ReadFieldMaybe
14820bool fasttest::U32Dflt_ReadFieldMaybe(fasttest::U32Dflt& parent, algo::strptr field, algo::strptr strval) {
14821    bool retval = true;
14822    fasttest::FieldId field_id;
14823    (void)value_SetStrptrMaybe(field_id,field);
14824    switch(field_id) {
14825        case fasttest_FieldId_base: {
14826            retval = false;
14827            break;
14828        }
14829        case fasttest_FieldId_length: {
14830            retval = false;
14831            break;
14832        }
14833        case fasttest_FieldId_id: {
14834            retval = false;
14835            break;
14836        }
14837        case fasttest_FieldId_Value: {
14838            retval = u32_ReadStrptrMaybe(parent.Value, strval);
14839            break;
14840        }
14841        default: break;
14842    }
14843    if (!retval) {
14844        algo_lib::AppendErrtext("attr",field);
14845    }
14846    return retval;
14847}
14848
14849// --- fasttest.U32Dflt..ReadStrptrMaybe
14850// Read fields of fasttest::U32Dflt from an ascii string.
14851// The format of the string is an ssim Tuple
14852bool fasttest::U32Dflt_ReadStrptrMaybe(fasttest::U32Dflt &parent, algo::strptr in_str) {
14853    bool retval = true;
14854    retval = algo::StripTypeTag(in_str, "fasttest.U32Dflt");
14855    ind_beg(algo::Attr_curs, attr, in_str) {
14856        retval = retval && U32Dflt_ReadFieldMaybe(parent, attr.name, attr.value);
14857    }ind_end;
14858    return retval;
14859}
14860
14861// --- fasttest.U32Dflt..Print
14862// print string representation of ROW to string STR
14863// cfmt:fasttest.U32Dflt.String  printfmt:Tuple
14864void fasttest::U32Dflt_Print(fasttest::U32Dflt& row, algo::cstring& str) {
14865    algo::tempstr temp;
14866    str << "fasttest.U32Dflt";
14867
14868    u32_Print(row.Value, temp);
14869    PrintAttrSpaceReset(str,"Value", temp);
14870}
14871
14872// --- fasttest.U32Dflt..FastEncode
14873void fasttest::U32Dflt_FastEncode(algo::ByteAry& buf, FastState& state, fasttest::U32Dflt& parent) {
14874    int index = ary_N(buf);
14875    u64 pmap(0);
14876    if (!tid_AssignedQ(state) || parent.id != state.tid) {
14877        lib_fast::EncodeUnsigned(buf,parent.id,false);
14878        lib_fast::SetPmapBit(pmap,0);
14879    }
14880    tid_SetAssigned(state);
14881    state.tid = parent.id;
14882    // Value unsigned default mandatory
14883    if (parent.Value != 36) {
14884        lib_fast::EncodeUnsigned(buf,parent.Value,false);
14885        lib_fast::SetPmapBit(pmap,1);
14886    }
14887    lib_fast::InsertPmap(buf,index,pmap);
14888}
14889
14890// --- fasttest.U32Dflt..FastDecode
14891bool fasttest::U32Dflt_FastDecode(algo::memptr& from, u64 pmap, FastState& state, fasttest::U32Dflt& parent) {
14892    bool ok = true;
14893    // Value unsigned default mandatory
14894    if (ok) {
14895        bool prs = lib_fast::GetPmapBit(pmap,1);
14896        if (prs) {
14897            ok = lib_fast::DecodeUnsigned(from,parent.Value,false);
14898            if (!ok) {
14899                state.error << "fasttest.U32Dflt.Value: bad Unsigned" << eol;
14900            }
14901        } else {
14902            parent.Value = 36;
14903        }
14904    }
14905    return ok;
14906}
14907
14908// --- fasttest.U32Dflt..FixEncode
14909void fasttest::U32Dflt_FixEncode(cstring& buf, fasttest::U32Dflt& parent, char soh) {
14910    buf << "1=" << parent.Value << soh;
14911}
14912
14913// --- fasttest.U32DfltNull.base.CopyOut
14914// Copy fields out of row
14915void fasttest::parent_CopyOut(fasttest::U32DfltNull &row, fasttest::TemplateHeader &out) {
14916    // length: field value is computed
14917    // id: field value is computed
14918    (void)row;//only to avoid -Wunused-parameter
14919    (void)out;//only to avoid -Wunused-parameter
14920}
14921
14922// --- fasttest.U32DfltNull.Value.ReadStrptrMaybe
14923inline static bool fasttest::Value_ReadStrptrMaybe(fasttest::U32DfltNull &parent, algo::strptr in_str) {
14924    bool retval = true;
14925    u32 Value_tmp;
14926    retval = u32_ReadStrptrMaybe(Value_tmp, in_str);
14927    if (retval) {
14928        Value_Set(parent, Value_tmp);
14929    }
14930    return retval;
14931}
14932
14933// --- fasttest.U32DfltNull.pmask_bitcurs.Next
14934// proceed to next item
14935void fasttest::U32DfltNull_pmask_bitcurs_Next(U32DfltNull_pmask_bitcurs &curs) {
14936    ++curs.bit;
14937    int index = curs.bit / 32;
14938    int offset = curs.bit % 32;
14939    for (; index < curs.n_elems; ++index, offset = 0) {
14940        u64 rest = curs.elems[index] >> offset;
14941        if (rest) {
14942            offset += algo::u64_BitScanForward(rest);
14943            break;
14944        }
14945    }
14946    curs.bit = index * 32 + offset;
14947}
14948
14949// --- fasttest.U32DfltNull..ReadFieldMaybe
14950bool fasttest::U32DfltNull_ReadFieldMaybe(fasttest::U32DfltNull& parent, algo::strptr field, algo::strptr strval) {
14951    bool retval = true;
14952    fasttest::FieldId field_id;
14953    (void)value_SetStrptrMaybe(field_id,field);
14954    switch(field_id) {
14955        case fasttest_FieldId_base: {
14956            retval = false;
14957            break;
14958        }
14959        case fasttest_FieldId_length: {
14960            retval = false;
14961            break;
14962        }
14963        case fasttest_FieldId_id: {
14964            retval = false;
14965            break;
14966        }
14967        case fasttest_FieldId_pmask: {
14968            retval = false;
14969            break;
14970        }
14971        case fasttest_FieldId_Value: {
14972            retval = Value_ReadStrptrMaybe(parent, strval);
14973            if (retval) {
14974                pmask_qSetBit(parent, 0);
14975            }
14976            break;
14977        }
14978        default: break;
14979    }
14980    if (!retval) {
14981        algo_lib::AppendErrtext("attr",field);
14982    }
14983    return retval;
14984}
14985
14986// --- fasttest.U32DfltNull..ReadStrptrMaybe
14987// Read fields of fasttest::U32DfltNull from an ascii string.
14988// The format of the string is an ssim Tuple
14989bool fasttest::U32DfltNull_ReadStrptrMaybe(fasttest::U32DfltNull &parent, algo::strptr in_str) {
14990    bool retval = true;
14991    retval = algo::StripTypeTag(in_str, "fasttest.U32DfltNull");
14992    ind_beg(algo::Attr_curs, attr, in_str) {
14993        retval = retval && U32DfltNull_ReadFieldMaybe(parent, attr.name, attr.value);
14994    }ind_end;
14995    return retval;
14996}
14997
14998// --- fasttest.U32DfltNull..Print
14999// print string representation of ROW to string STR
15000// cfmt:fasttest.U32DfltNull.String  printfmt:Tuple
15001void fasttest::U32DfltNull_Print(fasttest::U32DfltNull& row, algo::cstring& str) {
15002    algo::tempstr temp;
15003    str << "fasttest.U32DfltNull";
15004
15005    if (Value_PresentQ(row)) {
15006        u32_Print(row.Value, temp);
15007        PrintAttrSpaceReset(str,"Value", temp);
15008    }
15009}
15010
15011// --- fasttest.U32DfltNull..FastEncode
15012void fasttest::U32DfltNull_FastEncode(algo::ByteAry& buf, FastState& state, fasttest::U32DfltNull& parent) {
15013    int index = ary_N(buf);
15014    u64 pmap(0);
15015    if (!tid_AssignedQ(state) || parent.id != state.tid) {
15016        lib_fast::EncodeUnsigned(buf,parent.id,false);
15017        lib_fast::SetPmapBit(pmap,0);
15018    }
15019    tid_SetAssigned(state);
15020    state.tid = parent.id;
15021    // Value unsigned default optional
15022    if (Value_PresentQ(parent)) {
15023        lib_fast::EncodeUnsigned(buf,parent.Value,true);
15024        lib_fast::SetPmapBit(pmap,1);
15025    }
15026    lib_fast::InsertPmap(buf,index,pmap);
15027}
15028
15029// --- fasttest.U32DfltNull..FastDecode
15030bool fasttest::U32DfltNull_FastDecode(algo::memptr& from, u64 pmap, FastState& state, fasttest::U32DfltNull& parent) {
15031    bool ok = true;
15032    // Value unsigned default optional
15033    if (ok) {
15034        bool prs = lib_fast::GetPmapBit(pmap,1);
15035        if (prs) {
15036            prs = !lib_fast::DecodeNull(from);
15037            if (prs) {
15038                ok = lib_fast::DecodeUnsigned(from,parent.Value,true);
15039                if (!ok) {
15040                    state.error << "fasttest.U32DfltNull.Value: bad Unsigned" << eol;
15041                }
15042            }
15043        } else {
15044        }
15045        pmask_qSetBitVal(parent,Value_Present_GetBit(parent),prs);
15046    }
15047    return ok;
15048}
15049
15050// --- fasttest.U32DfltNull..FixEncode
15051void fasttest::U32DfltNull_FixEncode(cstring& buf, fasttest::U32DfltNull& parent, char soh) {
15052    if (Value_PresentQ(parent)) {
15053        buf << "1=" << parent.Value << soh;
15054    }
15055}
15056
15057// --- fasttest.U32DfltOpt.base.CopyOut
15058// Copy fields out of row
15059void fasttest::parent_CopyOut(fasttest::U32DfltOpt &row, fasttest::TemplateHeader &out) {
15060    // length: field value is computed
15061    // id: field value is computed
15062    (void)row;//only to avoid -Wunused-parameter
15063    (void)out;//only to avoid -Wunused-parameter
15064}
15065
15066// --- fasttest.U32DfltOpt.Value.ReadStrptrMaybe
15067inline static bool fasttest::Value_ReadStrptrMaybe(fasttest::U32DfltOpt &parent, algo::strptr in_str) {
15068    bool retval = true;
15069    u32 Value_tmp;
15070    retval = u32_ReadStrptrMaybe(Value_tmp, in_str);
15071    if (retval) {
15072        Value_Set(parent, Value_tmp);
15073    }
15074    return retval;
15075}
15076
15077// --- fasttest.U32DfltOpt.pmask_bitcurs.Next
15078// proceed to next item
15079void fasttest::U32DfltOpt_pmask_bitcurs_Next(U32DfltOpt_pmask_bitcurs &curs) {
15080    ++curs.bit;
15081    int index = curs.bit / 32;
15082    int offset = curs.bit % 32;
15083    for (; index < curs.n_elems; ++index, offset = 0) {
15084        u64 rest = curs.elems[index] >> offset;
15085        if (rest) {
15086            offset += algo::u64_BitScanForward(rest);
15087            break;
15088        }
15089    }
15090    curs.bit = index * 32 + offset;
15091}
15092
15093// --- fasttest.U32DfltOpt..ReadFieldMaybe
15094bool fasttest::U32DfltOpt_ReadFieldMaybe(fasttest::U32DfltOpt& parent, algo::strptr field, algo::strptr strval) {
15095    bool retval = true;
15096    fasttest::FieldId field_id;
15097    (void)value_SetStrptrMaybe(field_id,field);
15098    switch(field_id) {
15099        case fasttest_FieldId_base: {
15100            retval = false;
15101            break;
15102        }
15103        case fasttest_FieldId_length: {
15104            retval = false;
15105            break;
15106        }
15107        case fasttest_FieldId_id: {
15108            retval = false;
15109            break;
15110        }
15111        case fasttest_FieldId_pmask: {
15112            retval = false;
15113            break;
15114        }
15115        case fasttest_FieldId_Value: {
15116            retval = Value_ReadStrptrMaybe(parent, strval);
15117            if (retval) {
15118                pmask_qSetBit(parent, 0);
15119            }
15120            break;
15121        }
15122        default: break;
15123    }
15124    if (!retval) {
15125        algo_lib::AppendErrtext("attr",field);
15126    }
15127    return retval;
15128}
15129
15130// --- fasttest.U32DfltOpt..ReadStrptrMaybe
15131// Read fields of fasttest::U32DfltOpt from an ascii string.
15132// The format of the string is an ssim Tuple
15133bool fasttest::U32DfltOpt_ReadStrptrMaybe(fasttest::U32DfltOpt &parent, algo::strptr in_str) {
15134    bool retval = true;
15135    retval = algo::StripTypeTag(in_str, "fasttest.U32DfltOpt");
15136    ind_beg(algo::Attr_curs, attr, in_str) {
15137        retval = retval && U32DfltOpt_ReadFieldMaybe(parent, attr.name, attr.value);
15138    }ind_end;
15139    return retval;
15140}
15141
15142// --- fasttest.U32DfltOpt..Print
15143// print string representation of ROW to string STR
15144// cfmt:fasttest.U32DfltOpt.String  printfmt:Tuple
15145void fasttest::U32DfltOpt_Print(fasttest::U32DfltOpt& row, algo::cstring& str) {
15146    algo::tempstr temp;
15147    str << "fasttest.U32DfltOpt";
15148
15149    if (Value_PresentQ(row)) {
15150        u32_Print(row.Value, temp);
15151        PrintAttrSpaceReset(str,"Value", temp);
15152    }
15153}
15154
15155// --- fasttest.U32DfltOpt..FastEncode
15156void fasttest::U32DfltOpt_FastEncode(algo::ByteAry& buf, FastState& state, fasttest::U32DfltOpt& parent) {
15157    int index = ary_N(buf);
15158    u64 pmap(0);
15159    if (!tid_AssignedQ(state) || parent.id != state.tid) {
15160        lib_fast::EncodeUnsigned(buf,parent.id,false);
15161        lib_fast::SetPmapBit(pmap,0);
15162    }
15163    tid_SetAssigned(state);
15164    state.tid = parent.id;
15165    // Value unsigned default optional
15166    if (Value_PresentQ(parent)) {
15167        if (parent.Value != 37) {
15168            lib_fast::EncodeUnsigned(buf,parent.Value,true);
15169            lib_fast::SetPmapBit(pmap,1);
15170        }
15171    } else {
15172        lib_fast::EncodeNull(buf);
15173        lib_fast::SetPmapBit(pmap,1);
15174    }
15175    lib_fast::InsertPmap(buf,index,pmap);
15176}
15177
15178// --- fasttest.U32DfltOpt..FastDecode
15179bool fasttest::U32DfltOpt_FastDecode(algo::memptr& from, u64 pmap, FastState& state, fasttest::U32DfltOpt& parent) {
15180    bool ok = true;
15181    // Value unsigned default optional
15182    if (ok) {
15183        bool prs = lib_fast::GetPmapBit(pmap,1);
15184        if (prs) {
15185            prs = !lib_fast::DecodeNull(from);
15186            if (prs) {
15187                ok = lib_fast::DecodeUnsigned(from,parent.Value,true);
15188                if (!ok) {
15189                    state.error << "fasttest.U32DfltOpt.Value: bad Unsigned" << eol;
15190                }
15191            }
15192        } else {
15193            parent.Value = 37;
15194            prs = true;
15195        }
15196        pmask_qSetBitVal(parent,Value_Present_GetBit(parent),prs);
15197    }
15198    return ok;
15199}
15200
15201// --- fasttest.U32DfltOpt..FixEncode
15202void fasttest::U32DfltOpt_FixEncode(cstring& buf, fasttest::U32DfltOpt& parent, char soh) {
15203    if (Value_PresentQ(parent)) {
15204        buf << "1=" << parent.Value << soh;
15205    }
15206}
15207
15208// --- fasttest.U32Incr.base.CopyOut
15209// Copy fields out of row
15210void fasttest::parent_CopyOut(fasttest::U32Incr &row, fasttest::TemplateHeader &out) {
15211    // length: field value is computed
15212    // id: field value is computed
15213    (void)row;//only to avoid -Wunused-parameter
15214    (void)out;//only to avoid -Wunused-parameter
15215}
15216
15217// --- fasttest.U32Incr..ReadFieldMaybe
15218bool fasttest::U32Incr_ReadFieldMaybe(fasttest::U32Incr& parent, algo::strptr field, algo::strptr strval) {
15219    bool retval = true;
15220    fasttest::FieldId field_id;
15221    (void)value_SetStrptrMaybe(field_id,field);
15222    switch(field_id) {
15223        case fasttest_FieldId_base: {
15224            retval = false;
15225            break;
15226        }
15227        case fasttest_FieldId_length: {
15228            retval = false;
15229            break;
15230        }
15231        case fasttest_FieldId_id: {
15232            retval = false;
15233            break;
15234        }
15235        case fasttest_FieldId_Value101: {
15236            retval = u32_ReadStrptrMaybe(parent.Value101, strval);
15237            break;
15238        }
15239        default: break;
15240    }
15241    if (!retval) {
15242        algo_lib::AppendErrtext("attr",field);
15243    }
15244    return retval;
15245}
15246
15247// --- fasttest.U32Incr..ReadStrptrMaybe
15248// Read fields of fasttest::U32Incr from an ascii string.
15249// The format of the string is an ssim Tuple
15250bool fasttest::U32Incr_ReadStrptrMaybe(fasttest::U32Incr &parent, algo::strptr in_str) {
15251    bool retval = true;
15252    retval = algo::StripTypeTag(in_str, "fasttest.U32Incr");
15253    ind_beg(algo::Attr_curs, attr, in_str) {
15254        retval = retval && U32Incr_ReadFieldMaybe(parent, attr.name, attr.value);
15255    }ind_end;
15256    return retval;
15257}
15258
15259// --- fasttest.U32Incr..Print
15260// print string representation of ROW to string STR
15261// cfmt:fasttest.U32Incr.String  printfmt:Tuple
15262void fasttest::U32Incr_Print(fasttest::U32Incr& row, algo::cstring& str) {
15263    algo::tempstr temp;
15264    str << "fasttest.U32Incr";
15265
15266    u32_Print(row.Value101, temp);
15267    PrintAttrSpaceReset(str,"Value101", temp);
15268}
15269
15270// --- fasttest.U32Incr..FastEncode
15271void fasttest::U32Incr_FastEncode(algo::ByteAry& buf, FastState& state, fasttest::U32Incr& parent) {
15272    int index = ary_N(buf);
15273    u64 pmap(0);
15274    if (!tid_AssignedQ(state) || parent.id != state.tid) {
15275        lib_fast::EncodeUnsigned(buf,parent.id,false);
15276        lib_fast::SetPmapBit(pmap,0);
15277    }
15278    tid_SetAssigned(state);
15279    state.tid = parent.id;
15280    // Value101 unsigned increment mandatory
15281    if (Value101_AssignedQ(state)) {
15282        if (parent.Value101 != state.Value101 + 1) {
15283            lib_fast::EncodeUnsigned(buf,parent.Value101,false);
15284            lib_fast::SetPmapBit(pmap,1);
15285        }
15286    } else {
15287        if (parent.Value101 != 101) {
15288            lib_fast::EncodeUnsigned(buf,parent.Value101,false);
15289            lib_fast::SetPmapBit(pmap,1);
15290        }
15291    }
15292    state.Value101 = parent.Value101;
15293    Value101_SetAssigned(state);
15294    lib_fast::InsertPmap(buf,index,pmap);
15295}
15296
15297// --- fasttest.U32Incr..FastDecode
15298bool fasttest::U32Incr_FastDecode(algo::memptr& from, u64 pmap, FastState& state, fasttest::U32Incr& parent) {
15299    bool ok = true;
15300    // Value101 unsigned increment mandatory
15301    if (ok) {
15302        bool prs = lib_fast::GetPmapBit(pmap,1);
15303        if (prs) {
15304            ok = lib_fast::DecodeUnsigned(from,parent.Value101,false);
15305            if (!ok) {
15306                state.error << "fasttest.U32Incr.Value101: bad Unsigned" << eol;
15307            }
15308        } else if (Value101_AssignedQ(state)) {
15309            parent.Value101 = state.Value101 + 1;
15310        } else {
15311            parent.Value101 = 101;
15312        }
15313        Value101_SetAssigned(state);
15314        state.Value101 = parent.Value101;
15315    }
15316    return ok;
15317}
15318
15319// --- fasttest.U32Incr..FixEncode
15320void fasttest::U32Incr_FixEncode(cstring& buf, fasttest::U32Incr& parent, char soh) {
15321    buf << "1=" << parent.Value101 << soh;
15322}
15323
15324// --- fasttest.U32IncrNV.base.CopyOut
15325// Copy fields out of row
15326void fasttest::parent_CopyOut(fasttest::U32IncrNV &row, fasttest::TemplateHeader &out) {
15327    // length: field value is computed
15328    // id: field value is computed
15329    (void)row;//only to avoid -Wunused-parameter
15330    (void)out;//only to avoid -Wunused-parameter
15331}
15332
15333// --- fasttest.U32IncrNV..ReadFieldMaybe
15334bool fasttest::U32IncrNV_ReadFieldMaybe(fasttest::U32IncrNV& parent, algo::strptr field, algo::strptr strval) {
15335    bool retval = true;
15336    fasttest::FieldId field_id;
15337    (void)value_SetStrptrMaybe(field_id,field);
15338    switch(field_id) {
15339        case fasttest_FieldId_base: {
15340            retval = false;
15341            break;
15342        }
15343        case fasttest_FieldId_length: {
15344            retval = false;
15345            break;
15346        }
15347        case fasttest_FieldId_id: {
15348            retval = false;
15349            break;
15350        }
15351        case fasttest_FieldId_Value102: {
15352            retval = u32_ReadStrptrMaybe(parent.Value102, strval);
15353            break;
15354        }
15355        default: break;
15356    }
15357    if (!retval) {
15358        algo_lib::AppendErrtext("attr",field);
15359    }
15360    return retval;
15361}
15362
15363// --- fasttest.U32IncrNV..ReadStrptrMaybe
15364// Read fields of fasttest::U32IncrNV from an ascii string.
15365// The format of the string is an ssim Tuple
15366bool fasttest::U32IncrNV_ReadStrptrMaybe(fasttest::U32IncrNV &parent, algo::strptr in_str) {
15367    bool retval = true;
15368    retval = algo::StripTypeTag(in_str, "fasttest.U32IncrNV");
15369    ind_beg(algo::Attr_curs, attr, in_str) {
15370        retval = retval && U32IncrNV_ReadFieldMaybe(parent, attr.name, attr.value);
15371    }ind_end;
15372    return retval;
15373}
15374
15375// --- fasttest.U32IncrNV..Print
15376// print string representation of ROW to string STR
15377// cfmt:fasttest.U32IncrNV.String  printfmt:Tuple
15378void fasttest::U32IncrNV_Print(fasttest::U32IncrNV& row, algo::cstring& str) {
15379    algo::tempstr temp;
15380    str << "fasttest.U32IncrNV";
15381
15382    u32_Print(row.Value102, temp);
15383    PrintAttrSpaceReset(str,"Value102", temp);
15384}
15385
15386// --- fasttest.U32IncrNV..FastEncode
15387void fasttest::U32IncrNV_FastEncode(algo::ByteAry& buf, FastState& state, fasttest::U32IncrNV& parent) {
15388    int index = ary_N(buf);
15389    u64 pmap(0);
15390    if (!tid_AssignedQ(state) || parent.id != state.tid) {
15391        lib_fast::EncodeUnsigned(buf,parent.id,false);
15392        lib_fast::SetPmapBit(pmap,0);
15393    }
15394    tid_SetAssigned(state);
15395    state.tid = parent.id;
15396    // Value102 unsigned increment mandatory
15397    if (Value102_AssignedQ(state)) {
15398        if (parent.Value102 != state.Value102 + 1) {
15399            lib_fast::EncodeUnsigned(buf,parent.Value102,false);
15400            lib_fast::SetPmapBit(pmap,1);
15401        }
15402    } else {
15403        lib_fast::EncodeUnsigned(buf,parent.Value102,false);
15404        lib_fast::SetPmapBit(pmap,1);
15405    }
15406    state.Value102 = parent.Value102;
15407    Value102_SetAssigned(state);
15408    lib_fast::InsertPmap(buf,index,pmap);
15409}
15410
15411// --- fasttest.U32IncrNV..FastDecode
15412bool fasttest::U32IncrNV_FastDecode(algo::memptr& from, u64 pmap, FastState& state, fasttest::U32IncrNV& parent) {
15413    bool ok = true;
15414    // Value102 unsigned increment mandatory
15415    if (ok) {
15416        bool prs = lib_fast::GetPmapBit(pmap,1);
15417        if (prs) {
15418            ok = lib_fast::DecodeUnsigned(from,parent.Value102,false);
15419            if (!ok) {
15420                state.error << "fasttest.U32IncrNV.Value102: bad Unsigned" << eol;
15421            }
15422        } else if (Value102_AssignedQ(state)) {
15423            parent.Value102 = state.Value102 + 1;
15424        } else {
15425            ok = false;
15426            state.error << "fasttest.U32IncrNV.Value102: increment operator: previous value unassigned" << eol;
15427        }
15428        Value102_SetAssigned(state);
15429        state.Value102 = parent.Value102;
15430    }
15431    return ok;
15432}
15433
15434// --- fasttest.U32IncrNV..FixEncode
15435void fasttest::U32IncrNV_FixEncode(cstring& buf, fasttest::U32IncrNV& parent, char soh) {
15436    buf << "1=" << parent.Value102 << soh;
15437}
15438
15439// --- fasttest.U32IncrNull.base.CopyOut
15440// Copy fields out of row
15441void fasttest::parent_CopyOut(fasttest::U32IncrNull &row, fasttest::TemplateHeader &out) {
15442    // length: field value is computed
15443    // id: field value is computed
15444    (void)row;//only to avoid -Wunused-parameter
15445    (void)out;//only to avoid -Wunused-parameter
15446}
15447
15448// --- fasttest.U32IncrNull.Value104.ReadStrptrMaybe
15449inline static bool fasttest::Value104_ReadStrptrMaybe(fasttest::U32IncrNull &parent, algo::strptr in_str) {
15450    bool retval = true;
15451    u32 Value104_tmp;
15452    retval = u32_ReadStrptrMaybe(Value104_tmp, in_str);
15453    if (retval) {
15454        Value104_Set(parent, Value104_tmp);
15455    }
15456    return retval;
15457}
15458
15459// --- fasttest.U32IncrNull.pmask_bitcurs.Next
15460// proceed to next item
15461void fasttest::U32IncrNull_pmask_bitcurs_Next(U32IncrNull_pmask_bitcurs &curs) {
15462    ++curs.bit;
15463    int index = curs.bit / 32;
15464    int offset = curs.bit % 32;
15465    for (; index < curs.n_elems; ++index, offset = 0) {
15466        u64 rest = curs.elems[index] >> offset;
15467        if (rest) {
15468            offset += algo::u64_BitScanForward(rest);
15469            break;
15470        }
15471    }
15472    curs.bit = index * 32 + offset;
15473}
15474
15475// --- fasttest.U32IncrNull..ReadFieldMaybe
15476bool fasttest::U32IncrNull_ReadFieldMaybe(fasttest::U32IncrNull& parent, algo::strptr field, algo::strptr strval) {
15477    bool retval = true;
15478    fasttest::FieldId field_id;
15479    (void)value_SetStrptrMaybe(field_id,field);
15480    switch(field_id) {
15481        case fasttest_FieldId_base: {
15482            retval = false;
15483            break;
15484        }
15485        case fasttest_FieldId_length: {
15486            retval = false;
15487            break;
15488        }
15489        case fasttest_FieldId_id: {
15490            retval = false;
15491            break;
15492        }
15493        case fasttest_FieldId_pmask: {
15494            retval = false;
15495            break;
15496        }
15497        case fasttest_FieldId_Value104: {
15498            retval = Value104_ReadStrptrMaybe(parent, strval);
15499            if (retval) {
15500                pmask_qSetBit(parent, 0);
15501            }
15502            break;
15503        }
15504        default: break;
15505    }
15506    if (!retval) {
15507        algo_lib::AppendErrtext("attr",field);
15508    }
15509    return retval;
15510}
15511
15512// --- fasttest.U32IncrNull..ReadStrptrMaybe
15513// Read fields of fasttest::U32IncrNull from an ascii string.
15514// The format of the string is an ssim Tuple
15515bool fasttest::U32IncrNull_ReadStrptrMaybe(fasttest::U32IncrNull &parent, algo::strptr in_str) {
15516    bool retval = true;
15517    retval = algo::StripTypeTag(in_str, "fasttest.U32IncrNull");
15518    ind_beg(algo::Attr_curs, attr, in_str) {
15519        retval = retval && U32IncrNull_ReadFieldMaybe(parent, attr.name, attr.value);
15520    }ind_end;
15521    return retval;
15522}
15523
15524// --- fasttest.U32IncrNull..Print
15525// print string representation of ROW to string STR
15526// cfmt:fasttest.U32IncrNull.String  printfmt:Tuple
15527void fasttest::U32IncrNull_Print(fasttest::U32IncrNull& row, algo::cstring& str) {
15528    algo::tempstr temp;
15529    str << "fasttest.U32IncrNull";
15530
15531    if (Value104_PresentQ(row)) {
15532        u32_Print(row.Value104, temp);
15533        PrintAttrSpaceReset(str,"Value104", temp);
15534    }
15535}
15536
15537// --- fasttest.U32IncrNull..FastEncode
15538void fasttest::U32IncrNull_FastEncode(algo::ByteAry& buf, FastState& state, fasttest::U32IncrNull& parent) {
15539    int index = ary_N(buf);
15540    u64 pmap(0);
15541    if (!tid_AssignedQ(state) || parent.id != state.tid) {
15542        lib_fast::EncodeUnsigned(buf,parent.id,false);
15543        lib_fast::SetPmapBit(pmap,0);
15544    }
15545    tid_SetAssigned(state);
15546    state.tid = parent.id;
15547    // Value104 unsigned increment optional
15548    if (Value104_PresentQ(parent)) {
15549        if (Value104_AssignedQ(state)) {
15550            if (!Value104_PresentQ(state) || parent.Value104 != state.Value104 + 1) {
15551                lib_fast::EncodeUnsigned(buf,parent.Value104,true);
15552                lib_fast::SetPmapBit(pmap,1);
15553            }
15554        } else {
15555            lib_fast::EncodeUnsigned(buf,parent.Value104,true);
15556            lib_fast::SetPmapBit(pmap,1);
15557        }
15558    } else {
15559        if (!Value104_AssignedQ(state) || Value104_PresentQ(state)) {
15560            lib_fast::EncodeNull(buf);
15561            lib_fast::SetPmapBit(pmap,1);
15562        }
15563    }
15564    state.Value104 = parent.Value104;
15565    present_qSetBitVal(state,Value104_Present_GetBit(state),Value104_PresentQ(parent));
15566    Value104_SetAssigned(state);
15567    lib_fast::InsertPmap(buf,index,pmap);
15568}
15569
15570// --- fasttest.U32IncrNull..FastDecode
15571bool fasttest::U32IncrNull_FastDecode(algo::memptr& from, u64 pmap, FastState& state, fasttest::U32IncrNull& parent) {
15572    bool ok = true;
15573    // Value104 unsigned increment optional
15574    if (ok) {
15575        bool prs = lib_fast::GetPmapBit(pmap,1);
15576        if (prs) {
15577            prs = !lib_fast::DecodeNull(from);
15578            if (prs) {
15579                ok = lib_fast::DecodeUnsigned(from,parent.Value104,true);
15580                if (!ok) {
15581                    state.error << "fasttest.U32IncrNull.Value104: bad Unsigned" << eol;
15582                }
15583            }
15584        } else if (Value104_AssignedQ(state)) {
15585            parent.Value104 = state.Value104 + 1;
15586            prs = Value104_PresentQ(state);
15587        } else {
15588            prs = false;
15589        }
15590        pmask_qSetBitVal(parent,Value104_Present_GetBit(parent),prs);
15591        Value104_SetAssigned(state);
15592        present_qSetBitVal(state,Value104_Present_GetBit(state),prs);
15593        state.Value104 = parent.Value104;
15594    }
15595    return ok;
15596}
15597
15598// --- fasttest.U32IncrNull..FixEncode
15599void fasttest::U32IncrNull_FixEncode(cstring& buf, fasttest::U32IncrNull& parent, char soh) {
15600    if (Value104_PresentQ(parent)) {
15601        buf << "1=" << parent.Value104 << soh;
15602    }
15603}
15604
15605// --- fasttest.U32IncrOpt.base.CopyOut
15606// Copy fields out of row
15607void fasttest::parent_CopyOut(fasttest::U32IncrOpt &row, fasttest::TemplateHeader &out) {
15608    // length: field value is computed
15609    // id: field value is computed
15610    (void)row;//only to avoid -Wunused-parameter
15611    (void)out;//only to avoid -Wunused-parameter
15612}
15613
15614// --- fasttest.U32IncrOpt.Value103.ReadStrptrMaybe
15615inline static bool fasttest::Value103_ReadStrptrMaybe(fasttest::U32IncrOpt &parent, algo::strptr in_str) {
15616    bool retval = true;
15617    u32 Value103_tmp;
15618    retval = u32_ReadStrptrMaybe(Value103_tmp, in_str);
15619    if (retval) {
15620        Value103_Set(parent, Value103_tmp);
15621    }
15622    return retval;
15623}
15624
15625// --- fasttest.U32IncrOpt.pmask_bitcurs.Next
15626// proceed to next item
15627void fasttest::U32IncrOpt_pmask_bitcurs_Next(U32IncrOpt_pmask_bitcurs &curs) {
15628    ++curs.bit;
15629    int index = curs.bit / 32;
15630    int offset = curs.bit % 32;
15631    for (; index < curs.n_elems; ++index, offset = 0) {
15632        u64 rest = curs.elems[index] >> offset;
15633        if (rest) {
15634            offset += algo::u64_BitScanForward(rest);
15635            break;
15636        }
15637    }
15638    curs.bit = index * 32 + offset;
15639}
15640
15641// --- fasttest.U32IncrOpt..ReadFieldMaybe
15642bool fasttest::U32IncrOpt_ReadFieldMaybe(fasttest::U32IncrOpt& parent, algo::strptr field, algo::strptr strval) {
15643    bool retval = true;
15644    fasttest::FieldId field_id;
15645    (void)value_SetStrptrMaybe(field_id,field);
15646    switch(field_id) {
15647        case fasttest_FieldId_base: {
15648            retval = false;
15649            break;
15650        }
15651        case fasttest_FieldId_length: {
15652            retval = false;
15653            break;
15654        }
15655        case fasttest_FieldId_id: {
15656            retval = false;
15657            break;
15658        }
15659        case fasttest_FieldId_pmask: {
15660            retval = false;
15661            break;
15662        }
15663        case fasttest_FieldId_Value103: {
15664            retval = Value103_ReadStrptrMaybe(parent, strval);
15665            if (retval) {
15666                pmask_qSetBit(parent, 0);
15667            }
15668            break;
15669        }
15670        default: break;
15671    }
15672    if (!retval) {
15673        algo_lib::AppendErrtext("attr",field);
15674    }
15675    return retval;
15676}
15677
15678// --- fasttest.U32IncrOpt..ReadStrptrMaybe
15679// Read fields of fasttest::U32IncrOpt from an ascii string.
15680// The format of the string is an ssim Tuple
15681bool fasttest::U32IncrOpt_ReadStrptrMaybe(fasttest::U32IncrOpt &parent, algo::strptr in_str) {
15682    bool retval = true;
15683    retval = algo::StripTypeTag(in_str, "fasttest.U32IncrOpt");
15684    ind_beg(algo::Attr_curs, attr, in_str) {
15685        retval = retval && U32IncrOpt_ReadFieldMaybe(parent, attr.name, attr.value);
15686    }ind_end;
15687    return retval;
15688}
15689
15690// --- fasttest.U32IncrOpt..Print
15691// print string representation of ROW to string STR
15692// cfmt:fasttest.U32IncrOpt.String  printfmt:Tuple
15693void fasttest::U32IncrOpt_Print(fasttest::U32IncrOpt& row, algo::cstring& str) {
15694    algo::tempstr temp;
15695    str << "fasttest.U32IncrOpt";
15696
15697    if (Value103_PresentQ(row)) {
15698        u32_Print(row.Value103, temp);
15699        PrintAttrSpaceReset(str,"Value103", temp);
15700    }
15701}
15702
15703// --- fasttest.U32IncrOpt..FastEncode
15704void fasttest::U32IncrOpt_FastEncode(algo::ByteAry& buf, FastState& state, fasttest::U32IncrOpt& parent) {
15705    int index = ary_N(buf);
15706    u64 pmap(0);
15707    if (!tid_AssignedQ(state) || parent.id != state.tid) {
15708        lib_fast::EncodeUnsigned(buf,parent.id,false);
15709        lib_fast::SetPmapBit(pmap,0);
15710    }
15711    tid_SetAssigned(state);
15712    state.tid = parent.id;
15713    // Value103 unsigned increment optional
15714    if (Value103_PresentQ(parent)) {
15715        if (Value103_AssignedQ(state)) {
15716            if (!Value103_PresentQ(state) || parent.Value103 != state.Value103 + 1) {
15717                lib_fast::EncodeUnsigned(buf,parent.Value103,true);
15718                lib_fast::SetPmapBit(pmap,1);
15719            }
15720        } else {
15721            if (parent.Value103 != 103) {
15722                lib_fast::EncodeUnsigned(buf,parent.Value103,true);
15723                lib_fast::SetPmapBit(pmap,1);
15724            }
15725        }
15726    } else {
15727        if (!Value103_AssignedQ(state) || Value103_PresentQ(state)) {
15728            lib_fast::EncodeNull(buf);
15729            lib_fast::SetPmapBit(pmap,1);
15730        }
15731    }
15732    state.Value103 = parent.Value103;
15733    present_qSetBitVal(state,Value103_Present_GetBit(state),Value103_PresentQ(parent));
15734    Value103_SetAssigned(state);
15735    lib_fast::InsertPmap(buf,index,pmap);
15736}
15737
15738// --- fasttest.U32IncrOpt..FastDecode
15739bool fasttest::U32IncrOpt_FastDecode(algo::memptr& from, u64 pmap, FastState& state, fasttest::U32IncrOpt& parent) {
15740    bool ok = true;
15741    // Value103 unsigned increment optional
15742    if (ok) {
15743        bool prs = lib_fast::GetPmapBit(pmap,1);
15744        if (prs) {
15745            prs = !lib_fast::DecodeNull(from);
15746            if (prs) {
15747                ok = lib_fast::DecodeUnsigned(from,parent.Value103,true);
15748                if (!ok) {
15749                    state.error << "fasttest.U32IncrOpt.Value103: bad Unsigned" << eol;
15750                }
15751            }
15752        } else if (Value103_AssignedQ(state)) {
15753            parent.Value103 = state.Value103 + 1;
15754            prs = Value103_PresentQ(state);
15755        } else {
15756            parent.Value103 = 103;
15757            prs = true;
15758        }
15759        pmask_qSetBitVal(parent,Value103_Present_GetBit(parent),prs);
15760        Value103_SetAssigned(state);
15761        present_qSetBitVal(state,Value103_Present_GetBit(state),prs);
15762        state.Value103 = parent.Value103;
15763    }
15764    return ok;
15765}
15766
15767// --- fasttest.U32IncrOpt..FixEncode
15768void fasttest::U32IncrOpt_FixEncode(cstring& buf, fasttest::U32IncrOpt& parent, char soh) {
15769    if (Value103_PresentQ(parent)) {
15770        buf << "1=" << parent.Value103 << soh;
15771    }
15772}
15773
15774// --- fasttest.U32None.base.CopyOut
15775// Copy fields out of row
15776void fasttest::parent_CopyOut(fasttest::U32None &row, fasttest::TemplateHeader &out) {
15777    // length: field value is computed
15778    // id: field value is computed
15779    (void)row;//only to avoid -Wunused-parameter
15780    (void)out;//only to avoid -Wunused-parameter
15781}
15782
15783// --- fasttest.U32None..ReadFieldMaybe
15784bool fasttest::U32None_ReadFieldMaybe(fasttest::U32None& parent, algo::strptr field, algo::strptr strval) {
15785    bool retval = true;
15786    fasttest::FieldId field_id;
15787    (void)value_SetStrptrMaybe(field_id,field);
15788    switch(field_id) {
15789        case fasttest_FieldId_base: {
15790            retval = false;
15791            break;
15792        }
15793        case fasttest_FieldId_length: {
15794            retval = false;
15795            break;
15796        }
15797        case fasttest_FieldId_id: {
15798            retval = false;
15799            break;
15800        }
15801        case fasttest_FieldId_Value: {
15802            retval = u32_ReadStrptrMaybe(parent.Value, strval);
15803            break;
15804        }
15805        default: break;
15806    }
15807    if (!retval) {
15808        algo_lib::AppendErrtext("attr",field);
15809    }
15810    return retval;
15811}
15812
15813// --- fasttest.U32None..ReadStrptrMaybe
15814// Read fields of fasttest::U32None from an ascii string.
15815// The format of the string is an ssim Tuple
15816bool fasttest::U32None_ReadStrptrMaybe(fasttest::U32None &parent, algo::strptr in_str) {
15817    bool retval = true;
15818    retval = algo::StripTypeTag(in_str, "fasttest.U32None");
15819    ind_beg(algo::Attr_curs, attr, in_str) {
15820        retval = retval && U32None_ReadFieldMaybe(parent, attr.name, attr.value);
15821    }ind_end;
15822    return retval;
15823}
15824
15825// --- fasttest.U32None..Print
15826// print string representation of ROW to string STR
15827// cfmt:fasttest.U32None.String  printfmt:Tuple
15828void fasttest::U32None_Print(fasttest::U32None& row, algo::cstring& str) {
15829    algo::tempstr temp;
15830    str << "fasttest.U32None";
15831
15832    u32_Print(row.Value, temp);
15833    PrintAttrSpaceReset(str,"Value", temp);
15834}
15835
15836// --- fasttest.U32None..FastEncode
15837void fasttest::U32None_FastEncode(algo::ByteAry& buf, FastState& state, fasttest::U32None& parent) {
15838    int index = ary_N(buf);
15839    u64 pmap(0);
15840    if (!tid_AssignedQ(state) || parent.id != state.tid) {
15841        lib_fast::EncodeUnsigned(buf,parent.id,false);
15842        lib_fast::SetPmapBit(pmap,0);
15843    }
15844    tid_SetAssigned(state);
15845    state.tid = parent.id;
15846    // Value unsigned none mandatory
15847    lib_fast::EncodeUnsigned(buf,parent.Value,false);
15848    lib_fast::InsertPmap(buf,index,pmap);
15849}
15850
15851// --- fasttest.U32None..FastDecode
15852bool fasttest::U32None_FastDecode(algo::memptr& from, u64 pmap, FastState& state, fasttest::U32None& parent) {
15853    bool ok = true;
15854    // Value unsigned none mandatory
15855    if (ok) {
15856        ok = lib_fast::DecodeUnsigned(from,parent.Value,false);
15857        if (!ok) {
15858            state.error << "fasttest.U32None.Value: bad Unsigned" << eol;
15859        }
15860    }
15861    (void)pmap;//only to avoid -Wunused-parameter
15862    return ok;
15863}
15864
15865// --- fasttest.U32None..FixEncode
15866void fasttest::U32None_FixEncode(cstring& buf, fasttest::U32None& parent, char soh) {
15867    buf << "1=" << parent.Value << soh;
15868}
15869
15870// --- fasttest.U32NoneOpt.base.CopyOut
15871// Copy fields out of row
15872void fasttest::parent_CopyOut(fasttest::U32NoneOpt &row, fasttest::TemplateHeader &out) {
15873    // length: field value is computed
15874    // id: field value is computed
15875    (void)row;//only to avoid -Wunused-parameter
15876    (void)out;//only to avoid -Wunused-parameter
15877}
15878
15879// --- fasttest.U32NoneOpt.Value.ReadStrptrMaybe
15880inline static bool fasttest::Value_ReadStrptrMaybe(fasttest::U32NoneOpt &parent, algo::strptr in_str) {
15881    bool retval = true;
15882    u32 Value_tmp;
15883    retval = u32_ReadStrptrMaybe(Value_tmp, in_str);
15884    if (retval) {
15885        Value_Set(parent, Value_tmp);
15886    }
15887    return retval;
15888}
15889
15890// --- fasttest.U32NoneOpt.pmask_bitcurs.Next
15891// proceed to next item
15892void fasttest::U32NoneOpt_pmask_bitcurs_Next(U32NoneOpt_pmask_bitcurs &curs) {
15893    ++curs.bit;
15894    int index = curs.bit / 32;
15895    int offset = curs.bit % 32;
15896    for (; index < curs.n_elems; ++index, offset = 0) {
15897        u64 rest = curs.elems[index] >> offset;
15898        if (rest) {
15899            offset += algo::u64_BitScanForward(rest);
15900            break;
15901        }
15902    }
15903    curs.bit = index * 32 + offset;
15904}
15905
15906// --- fasttest.U32NoneOpt..ReadFieldMaybe
15907bool fasttest::U32NoneOpt_ReadFieldMaybe(fasttest::U32NoneOpt& parent, algo::strptr field, algo::strptr strval) {
15908    bool retval = true;
15909    fasttest::FieldId field_id;
15910    (void)value_SetStrptrMaybe(field_id,field);
15911    switch(field_id) {
15912        case fasttest_FieldId_base: {
15913            retval = false;
15914            break;
15915        }
15916        case fasttest_FieldId_length: {
15917            retval = false;
15918            break;
15919        }
15920        case fasttest_FieldId_id: {
15921            retval = false;
15922            break;
15923        }
15924        case fasttest_FieldId_pmask: {
15925            retval = false;
15926            break;
15927        }
15928        case fasttest_FieldId_Value: {
15929            retval = Value_ReadStrptrMaybe(parent, strval);
15930            if (retval) {
15931                pmask_qSetBit(parent, 0);
15932            }
15933            break;
15934        }
15935        default: break;
15936    }
15937    if (!retval) {
15938        algo_lib::AppendErrtext("attr",field);
15939    }
15940    return retval;
15941}
15942
15943// --- fasttest.U32NoneOpt..ReadStrptrMaybe
15944// Read fields of fasttest::U32NoneOpt from an ascii string.
15945// The format of the string is an ssim Tuple
15946bool fasttest::U32NoneOpt_ReadStrptrMaybe(fasttest::U32NoneOpt &parent, algo::strptr in_str) {
15947    bool retval = true;
15948    retval = algo::StripTypeTag(in_str, "fasttest.U32NoneOpt");
15949    ind_beg(algo::Attr_curs, attr, in_str) {
15950        retval = retval && U32NoneOpt_ReadFieldMaybe(parent, attr.name, attr.value);
15951    }ind_end;
15952    return retval;
15953}
15954
15955// --- fasttest.U32NoneOpt..Print
15956// print string representation of ROW to string STR
15957// cfmt:fasttest.U32NoneOpt.String  printfmt:Tuple
15958void fasttest::U32NoneOpt_Print(fasttest::U32NoneOpt& row, algo::cstring& str) {
15959    algo::tempstr temp;
15960    str << "fasttest.U32NoneOpt";
15961
15962    if (Value_PresentQ(row)) {
15963        u32_Print(row.Value, temp);
15964        PrintAttrSpaceReset(str,"Value", temp);
15965    }
15966}
15967
15968// --- fasttest.U32NoneOpt..FastEncode
15969void fasttest::U32NoneOpt_FastEncode(algo::ByteAry& buf, FastState& state, fasttest::U32NoneOpt& parent) {
15970    int index = ary_N(buf);
15971    u64 pmap(0);
15972    if (!tid_AssignedQ(state) || parent.id != state.tid) {
15973        lib_fast::EncodeUnsigned(buf,parent.id,false);
15974        lib_fast::SetPmapBit(pmap,0);
15975    }
15976    tid_SetAssigned(state);
15977    state.tid = parent.id;
15978    // Value unsigned none optional
15979    if (Value_PresentQ(parent)) {
15980        lib_fast::EncodeUnsigned(buf,parent.Value,true);
15981    } else {
15982        lib_fast::EncodeNull(buf);
15983    }
15984    lib_fast::InsertPmap(buf,index,pmap);
15985}
15986
15987// --- fasttest.U32NoneOpt..FastDecode
15988bool fasttest::U32NoneOpt_FastDecode(algo::memptr& from, u64 pmap, FastState& state, fasttest::U32NoneOpt& parent) {
15989    bool ok = true;
15990    // Value unsigned none optional
15991    if (ok) {
15992        bool prs = !lib_fast::DecodeNull(from);
15993        if (prs) {
15994            ok = lib_fast::DecodeUnsigned(from,parent.Value,true);
15995            if (!ok) {
15996                state.error << "fasttest.U32NoneOpt.Value: bad Unsigned" << eol;
15997            }
15998        }
15999        pmask_qSetBitVal(parent,Value_Present_GetBit(parent),prs);
16000    }
16001    (void)pmap;//only to avoid -Wunused-parameter
16002    return ok;
16003}
16004
16005// --- fasttest.U32NoneOpt..FixEncode
16006void fasttest::U32NoneOpt_FixEncode(cstring& buf, fasttest::U32NoneOpt& parent, char soh) {
16007    if (Value_PresentQ(parent)) {
16008        buf << "1=" << parent.Value << soh;
16009    }
16010}
16011
16012// --- fasttest...SizeCheck
16013inline static void fasttest::SizeCheck() {
16014}
16015
16016// --- fasttest...StaticCheck
16017void fasttest::StaticCheck() {
16018    // check that bitfield fits width
16019    algo_assert(sizeof(((fasttest::SampleSet*)0)->value)*8 >= 3);
16020    algo_assert(_offset_of(fasttest::FieldId, value) + sizeof(((fasttest::FieldId*)0)->value) == sizeof(fasttest::FieldId));
16021    algo_assert(_offset_of(fasttest::TemplateHeaderMsgsCase, value) + sizeof(((fasttest::TemplateHeaderMsgsCase*)0)->value) == sizeof(fasttest::TemplateHeaderMsgsCase));
16022    algo_assert(_offset_of(fasttest::TemplateHeader_curs, msglen) + sizeof(((fasttest::TemplateHeader_curs*)0)->msglen) == sizeof(fasttest::TemplateHeader_curs));
16023}
16024
16025// --- fasttest.TemplateHeaderMsgs..FastEncode
16026void fasttest::TemplateHeaderMsgs_FastEncode(algo::ByteAry &buf, FastState &state, fasttest::TemplateHeader &header)
16027 {
16028    switch (header.id) {
16029        case 23:
16030        fasttest::BVConst_FastEncode(buf,state,(fasttest::BVConst&)header);
16031        break;
16032        case 24:
16033        fasttest::BVConstOpt_FastEncode(buf,state,(fasttest::BVConstOpt&)header);
16034        break;
16035        case 58:
16036        fasttest::BVCopy_FastEncode(buf,state,(fasttest::BVCopy&)header);
16037        break;
16038        case 60:
16039        fasttest::BVCopyNull_FastEncode(buf,state,(fasttest::BVCopyNull&)header);
16040        break;
16041        case 59:
16042        fasttest::BVCopyOpt_FastEncode(buf,state,(fasttest::BVCopyOpt&)header);
16043        break;
16044        case 42:
16045        fasttest::BVDflt_FastEncode(buf,state,(fasttest::BVDflt&)header);
16046        break;
16047        case 44:
16048        fasttest::BVDfltNull_FastEncode(buf,state,(fasttest::BVDfltNull&)header);
16049        break;
16050        case 43:
16051        fasttest::BVDfltOpt_FastEncode(buf,state,(fasttest::BVDfltOpt&)header);
16052        break;
16053        case 7:
16054        fasttest::BVNone_FastEncode(buf,state,(fasttest::BVNone&)header);
16055        break;
16056        case 8:
16057        fasttest::BVNoneOpt_FastEncode(buf,state,(fasttest::BVNoneOpt&)header);
16058        break;
16059        case 115:
16060        fasttest::GroupSgmOpt_FastEncode(buf,state,(fasttest::GroupSgmOpt&)header);
16061        break;
16062        case 113:
16063        fasttest::GroupTrv_FastEncode(buf,state,(fasttest::GroupTrv&)header);
16064        break;
16065        case 114:
16066        fasttest::GroupTrvOpt_FastEncode(buf,state,(fasttest::GroupTrvOpt&)header);
16067        break;
16068        case 17:
16069        fasttest::I32Const_FastEncode(buf,state,(fasttest::I32Const&)header);
16070        break;
16071        case 18:
16072        fasttest::I32ConstOpt_FastEncode(buf,state,(fasttest::I32ConstOpt&)header);
16073        break;
16074        case 49:
16075        fasttest::I32Copy_FastEncode(buf,state,(fasttest::I32Copy&)header);
16076        break;
16077        case 51:
16078        fasttest::I32CopyNull_FastEncode(buf,state,(fasttest::I32CopyNull&)header);
16079        break;
16080        case 50:
16081        fasttest::I32CopyOpt_FastEncode(buf,state,(fasttest::I32CopyOpt&)header);
16082        break;
16083        case 65:
16084        fasttest::I32Delta_FastEncode(buf,state,(fasttest::I32Delta&)header);
16085        break;
16086        case 66:
16087        fasttest::I32DeltaImpl_FastEncode(buf,state,(fasttest::I32DeltaImpl&)header);
16088        break;
16089        case 68:
16090        fasttest::I32DeltaNull_FastEncode(buf,state,(fasttest::I32DeltaNull&)header);
16091        break;
16092        case 67:
16093        fasttest::I32DeltaOpt_FastEncode(buf,state,(fasttest::I32DeltaOpt&)header);
16094        break;
16095        case 33:
16096        fasttest::I32Dflt_FastEncode(buf,state,(fasttest::I32Dflt&)header);
16097        break;
16098        case 35:
16099        fasttest::I32DfltNull_FastEncode(buf,state,(fasttest::I32DfltNull&)header);
16100        break;
16101        case 34:
16102        fasttest::I32DfltOpt_FastEncode(buf,state,(fasttest::I32DfltOpt&)header);
16103        break;
16104        case 97:
16105        fasttest::I32Incr_FastEncode(buf,state,(fasttest::I32Incr&)header);
16106        break;
16107        case 98:
16108        fasttest::I32IncrNV_FastEncode(buf,state,(fasttest::I32IncrNV&)header);
16109        break;
16110        case 100:
16111        fasttest::I32IncrNull_FastEncode(buf,state,(fasttest::I32IncrNull&)header);
16112        break;
16113        case 99:
16114        fasttest::I32IncrOpt_FastEncode(buf,state,(fasttest::I32IncrOpt&)header);
16115        break;
16116        case 1:
16117        fasttest::I32None_FastEncode(buf,state,(fasttest::I32None&)header);
16118        break;
16119        case 2:
16120        fasttest::I32NoneOpt_FastEncode(buf,state,(fasttest::I32NoneOpt&)header);
16121        break;
16122        case 151:
16123        fasttest::MsgPmap_FastEncode(buf,state,(fasttest::MsgPmap&)header);
16124        break;
16125        case 120:
16126        fasttest::Reset_FastEncode(buf,state,(fasttest::Reset&)header);
16127        state.assigned = 0;
16128        state.present = 0;
16129        break;
16130        case 145:
16131        fasttest::SampleEnumConst_FastEncode(buf,state,(fasttest::SampleEnumConst&)header);
16132        break;
16133        case 147:
16134        fasttest::SampleEnumCopy_FastEncode(buf,state,(fasttest::SampleEnumCopy&)header);
16135        break;
16136        case 146:
16137        fasttest::SampleEnumDefault_FastEncode(buf,state,(fasttest::SampleEnumDefault&)header);
16138        break;
16139        case 148:
16140        fasttest::SampleSetConst_FastEncode(buf,state,(fasttest::SampleSetConst&)header);
16141        break;
16142        case 150:
16143        fasttest::SampleSetCopy_FastEncode(buf,state,(fasttest::SampleSetCopy&)header);
16144        break;
16145        case 149:
16146        fasttest::SampleSetDefault_FastEncode(buf,state,(fasttest::SampleSetDefault&)header);
16147        break;
16148        case 25:
16149        fasttest::SclConst_FastEncode(buf,state,(fasttest::SclConst&)header);
16150        break;
16151        case 26:
16152        fasttest::SclConstOpt_FastEncode(buf,state,(fasttest::SclConstOpt&)header);
16153        break;
16154        case 61:
16155        fasttest::SclCopy_FastEncode(buf,state,(fasttest::SclCopy&)header);
16156        break;
16157        case 63:
16158        fasttest::SclCopyNull_FastEncode(buf,state,(fasttest::SclCopyNull&)header);
16159        break;
16160        case 62:
16161        fasttest::SclCopyOpt_FastEncode(buf,state,(fasttest::SclCopyOpt&)header);
16162        break;
16163        case 81:
16164        fasttest::SclDelta_FastEncode(buf,state,(fasttest::SclDelta&)header);
16165        break;
16166        case 82:
16167        fasttest::SclDeltaImpl_FastEncode(buf,state,(fasttest::SclDeltaImpl&)header);
16168        break;
16169        case 84:
16170        fasttest::SclDeltaNull_FastEncode(buf,state,(fasttest::SclDeltaNull&)header);
16171        break;
16172        case 83:
16173        fasttest::SclDeltaOpt_FastEncode(buf,state,(fasttest::SclDeltaOpt&)header);
16174        break;
16175        case 45:
16176        fasttest::SclDflt_FastEncode(buf,state,(fasttest::SclDflt&)header);
16177        break;
16178        case 47:
16179        fasttest::SclDfltNull_FastEncode(buf,state,(fasttest::SclDfltNull&)header);
16180        break;
16181        case 46:
16182        fasttest::SclDfltOpt_FastEncode(buf,state,(fasttest::SclDfltOpt&)header);
16183        break;
16184        case 9:
16185        fasttest::SclNone_FastEncode(buf,state,(fasttest::SclNone&)header);
16186        break;
16187        case 10:
16188        fasttest::SclNoneOpt_FastEncode(buf,state,(fasttest::SclNoneOpt&)header);
16189        break;
16190        case 135:
16191        fasttest::SeqOrder_FastEncode(buf,state,(fasttest::SeqOrder&)header);
16192        break;
16193        case 118:
16194        fasttest::SeqSgmOpt_FastEncode(buf,state,(fasttest::SeqSgmOpt&)header);
16195        break;
16196        case 116:
16197        fasttest::SeqTrv_FastEncode(buf,state,(fasttest::SeqTrv&)header);
16198        break;
16199        case 131:
16200        fasttest::SeqTrvLenConst_FastEncode(buf,state,(fasttest::SeqTrvLenConst&)header);
16201        break;
16202        case 132:
16203        fasttest::SeqTrvLenConstOpt_FastEncode(buf,state,(fasttest::SeqTrvLenConstOpt&)header);
16204        break;
16205        case 133:
16206        fasttest::SeqTrvLenDflt_FastEncode(buf,state,(fasttest::SeqTrvLenDflt&)header);
16207        break;
16208        case 134:
16209        fasttest::SeqTrvLenDfltOpt_FastEncode(buf,state,(fasttest::SeqTrvLenDfltOpt&)header);
16210        break;
16211        case 129:
16212        fasttest::SeqTrvLenNone_FastEncode(buf,state,(fasttest::SeqTrvLenNone&)header);
16213        break;
16214        case 130:
16215        fasttest::SeqTrvLenNoneOpt_FastEncode(buf,state,(fasttest::SeqTrvLenNoneOpt&)header);
16216        break;
16217        case 117:
16218        fasttest::SeqTrvOpt_FastEncode(buf,state,(fasttest::SeqTrvOpt&)header);
16219        break;
16220        case 21:
16221        fasttest::StrConst_FastEncode(buf,state,(fasttest::StrConst&)header);
16222        break;
16223        case 22:
16224        fasttest::StrConstOpt_FastEncode(buf,state,(fasttest::StrConstOpt&)header);
16225        break;
16226        case 55:
16227        fasttest::StrCopy_FastEncode(buf,state,(fasttest::StrCopy&)header);
16228        break;
16229        case 57:
16230        fasttest::StrCopyNull_FastEncode(buf,state,(fasttest::StrCopyNull&)header);
16231        break;
16232        case 56:
16233        fasttest::StrCopyOpt_FastEncode(buf,state,(fasttest::StrCopyOpt&)header);
16234        break;
16235        case 39:
16236        fasttest::StrDflt_FastEncode(buf,state,(fasttest::StrDflt&)header);
16237        break;
16238        case 41:
16239        fasttest::StrDfltNull_FastEncode(buf,state,(fasttest::StrDfltNull&)header);
16240        break;
16241        case 40:
16242        fasttest::StrDfltOpt_FastEncode(buf,state,(fasttest::StrDfltOpt&)header);
16243        break;
16244        case 5:
16245        fasttest::StrNone_FastEncode(buf,state,(fasttest::StrNone&)header);
16246        break;
16247        case 6:
16248        fasttest::StrNoneOpt_FastEncode(buf,state,(fasttest::StrNoneOpt&)header);
16249        break;
16250        case 19:
16251        fasttest::U32Const_FastEncode(buf,state,(fasttest::U32Const&)header);
16252        break;
16253        case 20:
16254        fasttest::U32ConstOpt_FastEncode(buf,state,(fasttest::U32ConstOpt&)header);
16255        break;
16256        case 52:
16257        fasttest::U32Copy_FastEncode(buf,state,(fasttest::U32Copy&)header);
16258        break;
16259        case 54:
16260        fasttest::U32CopyNull_FastEncode(buf,state,(fasttest::U32CopyNull&)header);
16261        break;
16262        case 53:
16263        fasttest::U32CopyOpt_FastEncode(buf,state,(fasttest::U32CopyOpt&)header);
16264        break;
16265        case 69:
16266        fasttest::U32Delta_FastEncode(buf,state,(fasttest::U32Delta&)header);
16267        break;
16268        case 70:
16269        fasttest::U32DeltaImpl_FastEncode(buf,state,(fasttest::U32DeltaImpl&)header);
16270        break;
16271        case 72:
16272        fasttest::U32DeltaNull_FastEncode(buf,state,(fasttest::U32DeltaNull&)header);
16273        break;
16274        case 71:
16275        fasttest::U32DeltaOpt_FastEncode(buf,state,(fasttest::U32DeltaOpt&)header);
16276        break;
16277        case 36:
16278        fasttest::U32Dflt_FastEncode(buf,state,(fasttest::U32Dflt&)header);
16279        break;
16280        case 38:
16281        fasttest::U32DfltNull_FastEncode(buf,state,(fasttest::U32DfltNull&)header);
16282        break;
16283        case 37:
16284        fasttest::U32DfltOpt_FastEncode(buf,state,(fasttest::U32DfltOpt&)header);
16285        break;
16286        case 101:
16287        fasttest::U32Incr_FastEncode(buf,state,(fasttest::U32Incr&)header);
16288        break;
16289        case 102:
16290        fasttest::U32IncrNV_FastEncode(buf,state,(fasttest::U32IncrNV&)header);
16291        break;
16292        case 104:
16293        fasttest::U32IncrNull_FastEncode(buf,state,(fasttest::U32IncrNull&)header);
16294        break;
16295        case 103:
16296        fasttest::U32IncrOpt_FastEncode(buf,state,(fasttest::U32IncrOpt&)header);
16297        break;
16298        case 3:
16299        fasttest::U32None_FastEncode(buf,state,(fasttest::U32None&)header);
16300        break;
16301        case 4:
16302        fasttest::U32NoneOpt_FastEncode(buf,state,(fasttest::U32NoneOpt&)header);
16303        break;
16304    }
16305}
16306
16307// --- fasttest.TemplateHeaderMsgs..FastDecode
16308fasttest::TemplateHeader * fasttest::TemplateHeaderMsgs_FastDecode(algo::memptr &from, FastState &state,algo::ByteAry &buf) {
16309    int index = ary_N(buf);
16310    TemplateHeader *ret(NULL);
16311    u64 pmap;
16312    u32 tid(0);
16313    bool ok = lib_fast::DecodePmap(from,pmap);
16314    if (!ok) {
16315        state.error << "fasttest.TemplateHeader: bad pmap" << eol;
16316    }
16317    if (ok) {
16318        bool prs = lib_fast::GetPmapBit(pmap,0);
16319        if (prs) {
16320            ok = lib_fast::DecodeUnsigned(from,tid,false);
16321            if (!ok) {
16322                state.error << "fasttest.TemplateHeader.id: bad Unsigned" << eol;
16323            }
16324        } else if (tid_AssignedQ(state)) {
16325            tid = state.tid;
16326        } else {
16327            ok = false;
16328            state.error << "fasttest.TemplateHeader.id: copy operator: previous value unassigned" << eol;
16329        }
16330        tid_SetAssigned(state);
16331        state.tid = tid;
16332    }
16333    if (ok) {
16334        switch (tid) {
16335            case 23:
16336            {
16337                fasttest::BVConst &msg = *new(ary_AllocN(buf,sizeof msg).elems) fasttest::BVConst;
16338                ok = BVConst_FastDecode(from,pmap,state,msg);
16339                ret = ok ? &Castbase(*(fasttest::BVConst*)(buf.ary_elems+index)) :  NULL;
16340            }
16341            break;
16342            case 24:
16343            {
16344                fasttest::BVConstOpt &msg = *new(ary_AllocN(buf,sizeof msg).elems) fasttest::BVConstOpt;
16345                ok = BVConstOpt_FastDecode(from,pmap,state,msg);
16346                ret = ok ? &Castbase(*(fasttest::BVConstOpt*)(buf.ary_elems+index)) :  NULL;
16347            }
16348            break;
16349            case 58:
16350            {
16351                fasttest::BVCopy &msg = *new(ary_AllocN(buf,sizeof msg).elems) fasttest::BVCopy;
16352                ok = BVCopy_FastDecode(from,pmap,state,msg);
16353                ret = ok ? &Castbase(*(fasttest::BVCopy*)(buf.ary_elems+index)) :  NULL;
16354            }
16355            break;
16356            case 60:
16357            {
16358                fasttest::BVCopyNull &msg = *new(ary_AllocN(buf,sizeof msg).elems) fasttest::BVCopyNull;
16359                ok = BVCopyNull_FastDecode(from,pmap,state,msg);
16360                ret = ok ? &Castbase(*(fasttest::BVCopyNull*)(buf.ary_elems+index)) :  NULL;
16361            }
16362            break;
16363            case 59:
16364            {
16365                fasttest::BVCopyOpt &msg = *new(ary_AllocN(buf,sizeof msg).elems) fasttest::BVCopyOpt;
16366                ok = BVCopyOpt_FastDecode(from,pmap,state,msg);
16367                ret = ok ? &Castbase(*(fasttest::BVCopyOpt*)(buf.ary_elems+index)) :  NULL;
16368            }
16369            break;
16370            case 42:
16371            {
16372                fasttest::BVDflt &msg = *new(ary_AllocN(buf,sizeof msg).elems) fasttest::BVDflt;
16373                ok = BVDflt_FastDecode(from,pmap,state,msg);
16374                ret = ok ? &Castbase(*(fasttest::BVDflt*)(buf.ary_elems+index)) :  NULL;
16375            }
16376            break;
16377            case 44:
16378            {
16379                fasttest::BVDfltNull &msg = *new(ary_AllocN(buf,sizeof msg).elems) fasttest::BVDfltNull;
16380                ok = BVDfltNull_FastDecode(from,pmap,state,msg);
16381                ret = ok ? &Castbase(*(fasttest::BVDfltNull*)(buf.ary_elems+index)) :  NULL;
16382            }
16383            break;
16384            case 43:
16385            {
16386                fasttest::BVDfltOpt &msg = *new(ary_AllocN(buf,sizeof msg).elems) fasttest::BVDfltOpt;
16387                ok = BVDfltOpt_FastDecode(from,pmap,state,msg);
16388                ret = ok ? &Castbase(*(fasttest::BVDfltOpt*)(buf.ary_elems+index)) :  NULL;
16389            }
16390            break;
16391            case 7:
16392            {
16393                fasttest::BVNone &msg = *new(ary_AllocN(buf,sizeof msg).elems) fasttest::BVNone;
16394                ok = BVNone_FastDecode(from,pmap,state,msg);
16395                ret = ok ? &Castbase(*(fasttest::BVNone*)(buf.ary_elems+index)) :  NULL;
16396            }
16397            break;
16398            case 8:
16399            {
16400                fasttest::BVNoneOpt &msg = *new(ary_AllocN(buf,sizeof msg).elems) fasttest::BVNoneOpt;
16401                ok = BVNoneOpt_FastDecode(from,pmap,state,msg);
16402                ret = ok ? &Castbase(*(fasttest::BVNoneOpt*)(buf.ary_elems+index)) :  NULL;
16403            }
16404            break;
16405            case 115:
16406            {
16407                fasttest::GroupSgmOpt &msg = *new(ary_AllocN(buf,sizeof msg).elems) fasttest::GroupSgmOpt;
16408                ok = GroupSgmOpt_FastDecode(from,pmap,state,msg);
16409                ret = ok ? &Castbase(*(fasttest::GroupSgmOpt*)(buf.ary_elems+index)) :  NULL;
16410            }
16411            break;
16412            case 113:
16413            {
16414                fasttest::GroupTrv &msg = *new(ary_AllocN(buf,sizeof msg).elems) fasttest::GroupTrv;
16415                ok = GroupTrv_FastDecode(from,pmap,state,msg);
16416                ret = ok ? &Castbase(*(fasttest::GroupTrv*)(buf.ary_elems+index)) :  NULL;
16417            }
16418            break;
16419            case 114:
16420            {
16421                fasttest::GroupTrvOpt &msg = *new(ary_AllocN(buf,sizeof msg).elems) fasttest::GroupTrvOpt;
16422                ok = GroupTrvOpt_FastDecode(from,pmap,state,msg);
16423                ret = ok ? &Castbase(*(fasttest::GroupTrvOpt*)(buf.ary_elems+index)) :  NULL;
16424            }
16425            break;
16426            case 17:
16427            {
16428                fasttest::I32Const &msg = *new(ary_AllocN(buf,sizeof msg).elems) fasttest::I32Const;
16429                ok = I32Const_FastDecode(from,pmap,state,msg);
16430                ret = ok ? &Castbase(*(fasttest::I32Const*)(buf.ary_elems+index)) :  NULL;
16431            }
16432            break;
16433            case 18:
16434            {
16435                fasttest::I32ConstOpt &msg = *new(ary_AllocN(buf,sizeof msg).elems) fasttest::I32ConstOpt;
16436                ok = I32ConstOpt_FastDecode(from,pmap,state,msg);
16437                ret = ok ? &Castbase(*(fasttest::I32ConstOpt*)(buf.ary_elems+index)) :  NULL;
16438            }
16439            break;
16440            case 49:
16441            {
16442                fasttest::I32Copy &msg = *new(ary_AllocN(buf,sizeof msg).elems) fasttest::I32Copy;
16443                ok = I32Copy_FastDecode(from,pmap,state,msg);
16444                ret = ok ? &Castbase(*(fasttest::I32Copy*)(buf.ary_elems+index)) :  NULL;
16445            }
16446            break;
16447            case 51:
16448            {
16449                fasttest::I32CopyNull &msg = *new(ary_AllocN(buf,sizeof msg).elems) fasttest::I32CopyNull;
16450                ok = I32CopyNull_FastDecode(from,pmap,state,msg);
16451                ret = ok ? &Castbase(*(fasttest::I32CopyNull*)(buf.ary_elems+index)) :  NULL;
16452            }
16453            break;
16454            case 50:
16455            {
16456                fasttest::I32CopyOpt &msg = *new(ary_AllocN(buf,sizeof msg).elems) fasttest::I32CopyOpt;
16457                ok = I32CopyOpt_FastDecode(from,pmap,state,msg);
16458                ret = ok ? &Castbase(*(fasttest::I32CopyOpt*)(buf.ary_elems+index)) :  NULL;
16459            }
16460            break;
16461            case 65:
16462            {
16463                fasttest::I32Delta &msg = *new(ary_AllocN(buf,sizeof msg).elems) fasttest::I32Delta;
16464                ok = I32Delta_FastDecode(from,pmap,state,msg);
16465                ret = ok ? &Castbase(*(fasttest::I32Delta*)(buf.ary_elems+index)) :  NULL;
16466            }
16467            break;
16468            case 66:
16469            {
16470                fasttest::I32DeltaImpl &msg = *new(ary_AllocN(buf,sizeof msg).elems) fasttest::I32DeltaImpl;
16471                ok = I32DeltaImpl_FastDecode(from,pmap,state,msg);
16472                ret = ok ? &Castbase(*(fasttest::I32DeltaImpl*)(buf.ary_elems+index)) :  NULL;
16473            }
16474            break;
16475            case 68:
16476            {
16477                fasttest::I32DeltaNull &msg = *new(ary_AllocN(buf,sizeof msg).elems) fasttest::I32DeltaNull;
16478                ok = I32DeltaNull_FastDecode(from,pmap,state,msg);
16479                ret = ok ? &Castbase(*(fasttest::I32DeltaNull*)(buf.ary_elems+index)) :  NULL;
16480            }
16481            break;
16482            case 67:
16483            {
16484                fasttest::I32DeltaOpt &msg = *new(ary_AllocN(buf,sizeof msg).elems) fasttest::I32DeltaOpt;
16485                ok = I32DeltaOpt_FastDecode(from,pmap,state,msg);
16486                ret = ok ? &Castbase(*(fasttest::I32DeltaOpt*)(buf.ary_elems+index)) :  NULL;
16487            }
16488            break;
16489            case 33:
16490            {
16491                fasttest::I32Dflt &msg = *new(ary_AllocN(buf,sizeof msg).elems) fasttest::I32Dflt;
16492                ok = I32Dflt_FastDecode(from,pmap,state,msg);
16493                ret = ok ? &Castbase(*(fasttest::I32Dflt*)(buf.ary_elems+index)) :  NULL;
16494            }
16495            break;
16496            case 35:
16497            {
16498                fasttest::I32DfltNull &msg = *new(ary_AllocN(buf,sizeof msg).elems) fasttest::I32DfltNull;
16499                ok = I32DfltNull_FastDecode(from,pmap,state,msg);
16500                ret = ok ? &Castbase(*(fasttest::I32DfltNull*)(buf.ary_elems+index)) :  NULL;
16501            }
16502            break;
16503            case 34:
16504            {
16505                fasttest::I32DfltOpt &msg = *new(ary_AllocN(buf,sizeof msg).elems) fasttest::I32DfltOpt;
16506                ok = I32DfltOpt_FastDecode(from,pmap,state,msg);
16507                ret = ok ? &Castbase(*(fasttest::I32DfltOpt*)(buf.ary_elems+index)) :  NULL;
16508            }
16509            break;
16510            case 97:
16511            {
16512                fasttest::I32Incr &msg = *new(ary_AllocN(buf,sizeof msg).elems) fasttest::I32Incr;
16513                ok = I32Incr_FastDecode(from,pmap,state,msg);
16514                ret = ok ? &Castbase(*(fasttest::I32Incr*)(buf.ary_elems+index)) :  NULL;
16515            }
16516            break;
16517            case 98:
16518            {
16519                fasttest::I32IncrNV &msg = *new(ary_AllocN(buf,sizeof msg).elems) fasttest::I32IncrNV;
16520                ok = I32IncrNV_FastDecode(from,pmap,state,msg);
16521                ret = ok ? &Castbase(*(fasttest::I32IncrNV*)(buf.ary_elems+index)) :  NULL;
16522            }
16523            break;
16524            case 100:
16525            {
16526                fasttest::I32IncrNull &msg = *new(ary_AllocN(buf,sizeof msg).elems) fasttest::I32IncrNull;
16527                ok = I32IncrNull_FastDecode(from,pmap,state,msg);
16528                ret = ok ? &Castbase(*(fasttest::I32IncrNull*)(buf.ary_elems+index)) :  NULL;
16529            }
16530            break;
16531            case 99:
16532            {
16533                fasttest::I32IncrOpt &msg = *new(ary_AllocN(buf,sizeof msg).elems) fasttest::I32IncrOpt;
16534                ok = I32IncrOpt_FastDecode(from,pmap,state,msg);
16535                ret = ok ? &Castbase(*(fasttest::I32IncrOpt*)(buf.ary_elems+index)) :  NULL;
16536            }
16537            break;
16538            case 1:
16539            {
16540                fasttest::I32None &msg = *new(ary_AllocN(buf,sizeof msg).elems) fasttest::I32None;
16541                ok = I32None_FastDecode(from,pmap,state,msg);
16542                ret = ok ? &Castbase(*(fasttest::I32None*)(buf.ary_elems+index)) :  NULL;
16543            }
16544            break;
16545            case 2:
16546            {
16547                fasttest::I32NoneOpt &msg = *new(ary_AllocN(buf,sizeof msg).elems) fasttest::I32NoneOpt;
16548                ok = I32NoneOpt_FastDecode(from,pmap,state,msg);
16549                ret = ok ? &Castbase(*(fasttest::I32NoneOpt*)(buf.ary_elems+index)) :  NULL;
16550            }
16551            break;
16552            case 151:
16553            {
16554                fasttest::MsgPmap &msg = *new(ary_AllocN(buf,sizeof msg).elems) fasttest::MsgPmap;
16555                ok = MsgPmap_FastDecode(from,pmap,state,msg);
16556                ret = ok ? &Castbase(*(fasttest::MsgPmap*)(buf.ary_elems+index)) :  NULL;
16557            }
16558            break;
16559            case 120:
16560            {
16561                state.assigned = 0;
16562                state.present = 0;
16563                fasttest::Reset &msg = *new(ary_AllocN(buf,sizeof msg).elems) fasttest::Reset;
16564                ok = Reset_FastDecode(from,pmap,state,msg);
16565                ret = ok ? &Castbase(*(fasttest::Reset*)(buf.ary_elems+index)) :  NULL;
16566            }
16567            break;
16568            case 145:
16569            {
16570                fasttest::SampleEnumConst &msg = *new(ary_AllocN(buf,sizeof msg).elems) fasttest::SampleEnumConst;
16571                ok = SampleEnumConst_FastDecode(from,pmap,state,msg);
16572                ret = ok ? &Castbase(*(fasttest::SampleEnumConst*)(buf.ary_elems+index)) :  NULL;
16573            }
16574            break;
16575            case 147:
16576            {
16577                fasttest::SampleEnumCopy &msg = *new(ary_AllocN(buf,sizeof msg).elems) fasttest::SampleEnumCopy;
16578                ok = SampleEnumCopy_FastDecode(from,pmap,state,msg);
16579                ret = ok ? &Castbase(*(fasttest::SampleEnumCopy*)(buf.ary_elems+index)) :  NULL;
16580            }
16581            break;
16582            case 146:
16583            {
16584                fasttest::SampleEnumDefault &msg = *new(ary_AllocN(buf,sizeof msg).elems) fasttest::SampleEnumDefault;
16585                ok = SampleEnumDefault_FastDecode(from,pmap,state,msg);
16586                ret = ok ? &Castbase(*(fasttest::SampleEnumDefault*)(buf.ary_elems+index)) :  NULL;
16587            }
16588            break;
16589            case 148:
16590            {
16591                fasttest::SampleSetConst &msg = *new(ary_AllocN(buf,sizeof msg).elems) fasttest::SampleSetConst;
16592                ok = SampleSetConst_FastDecode(from,pmap,state,msg);
16593                ret = ok ? &Castbase(*(fasttest::SampleSetConst*)(buf.ary_elems+index)) :  NULL;
16594            }
16595            break;
16596            case 150:
16597            {
16598                fasttest::SampleSetCopy &msg = *new(ary_AllocN(buf,sizeof msg).elems) fasttest::SampleSetCopy;
16599                ok = SampleSetCopy_FastDecode(from,pmap,state,msg);
16600                ret = ok ? &Castbase(*(fasttest::SampleSetCopy*)(buf.ary_elems+index)) :  NULL;
16601            }
16602            break;
16603            case 149:
16604            {
16605                fasttest::SampleSetDefault &msg = *new(ary_AllocN(buf,sizeof msg).elems) fasttest::SampleSetDefault;
16606                ok = SampleSetDefault_FastDecode(from,pmap,state,msg);
16607                ret = ok ? &Castbase(*(fasttest::SampleSetDefault*)(buf.ary_elems+index)) :  NULL;
16608            }
16609            break;
16610            case 25:
16611            {
16612                fasttest::SclConst &msg = *new(ary_AllocN(buf,sizeof msg).elems) fasttest::SclConst;
16613                ok = SclConst_FastDecode(from,pmap,state,msg);
16614                ret = ok ? &Castbase(*(fasttest::SclConst*)(buf.ary_elems+index)) :  NULL;
16615            }
16616            break;
16617            case 26:
16618            {
16619                fasttest::SclConstOpt &msg = *new(ary_AllocN(buf,sizeof msg).elems) fasttest::SclConstOpt;
16620                ok = SclConstOpt_FastDecode(from,pmap,state,msg);
16621                ret = ok ? &Castbase(*(fasttest::SclConstOpt*)(buf.ary_elems+index)) :  NULL;
16622            }
16623            break;
16624            case 61:
16625            {
16626                fasttest::SclCopy &msg = *new(ary_AllocN(buf,sizeof msg).elems) fasttest::SclCopy;
16627                ok = SclCopy_FastDecode(from,pmap,state,msg);
16628                ret = ok ? &Castbase(*(fasttest::SclCopy*)(buf.ary_elems+index)) :  NULL;
16629            }
16630            break;
16631            case 63:
16632            {
16633                fasttest::SclCopyNull &msg = *new(ary_AllocN(buf,sizeof msg).elems) fasttest::SclCopyNull;
16634                ok = SclCopyNull_FastDecode(from,pmap,state,msg);
16635                ret = ok ? &Castbase(*(fasttest::SclCopyNull*)(buf.ary_elems+index)) :  NULL;
16636            }
16637            break;
16638            case 62:
16639            {
16640                fasttest::SclCopyOpt &msg = *new(ary_AllocN(buf,sizeof msg).elems) fasttest::SclCopyOpt;
16641                ok = SclCopyOpt_FastDecode(from,pmap,state,msg);
16642                ret = ok ? &Castbase(*(fasttest::SclCopyOpt*)(buf.ary_elems+index)) :  NULL;
16643            }
16644            break;
16645            case 81:
16646            {
16647                fasttest::SclDelta &msg = *new(ary_AllocN(buf,sizeof msg).elems) fasttest::SclDelta;
16648                ok = SclDelta_FastDecode(from,pmap,state,msg);
16649                ret = ok ? &Castbase(*(fasttest::SclDelta*)(buf.ary_elems+index)) :  NULL;
16650            }
16651            break;
16652            case 82:
16653            {
16654                fasttest::SclDeltaImpl &msg = *new(ary_AllocN(buf,sizeof msg).elems) fasttest::SclDeltaImpl;
16655                ok = SclDeltaImpl_FastDecode(from,pmap,state,msg);
16656                ret = ok ? &Castbase(*(fasttest::SclDeltaImpl*)(buf.ary_elems+index)) :  NULL;
16657            }
16658            break;
16659            case 84:
16660            {
16661                fasttest::SclDeltaNull &msg = *new(ary_AllocN(buf,sizeof msg).elems) fasttest::SclDeltaNull;
16662                ok = SclDeltaNull_FastDecode(from,pmap,state,msg);
16663                ret = ok ? &Castbase(*(fasttest::SclDeltaNull*)(buf.ary_elems+index)) :  NULL;
16664            }
16665            break;
16666            case 83:
16667            {
16668                fasttest::SclDeltaOpt &msg = *new(ary_AllocN(buf,sizeof msg).elems) fasttest::SclDeltaOpt;
16669                ok = SclDeltaOpt_FastDecode(from,pmap,state,msg);
16670                ret = ok ? &Castbase(*(fasttest::SclDeltaOpt*)(buf.ary_elems+index)) :  NULL;
16671            }
16672            break;
16673            case 45:
16674            {
16675                fasttest::SclDflt &msg = *new(ary_AllocN(buf,sizeof msg).elems) fasttest::SclDflt;
16676                ok = SclDflt_FastDecode(from,pmap,state,msg);
16677                ret = ok ? &Castbase(*(fasttest::SclDflt*)(buf.ary_elems+index)) :  NULL;
16678            }
16679            break;
16680            case 47:
16681            {
16682                fasttest::SclDfltNull &msg = *new(ary_AllocN(buf,sizeof msg).elems) fasttest::SclDfltNull;
16683                ok = SclDfltNull_FastDecode(from,pmap,state,msg);
16684                ret = ok ? &Castbase(*(fasttest::SclDfltNull*)(buf.ary_elems+index)) :  NULL;
16685            }
16686            break;
16687            case 46:
16688            {
16689                fasttest::SclDfltOpt &msg = *new(ary_AllocN(buf,sizeof msg).elems) fasttest::SclDfltOpt;
16690                ok = SclDfltOpt_FastDecode(from,pmap,state,msg);
16691                ret = ok ? &Castbase(*(fasttest::SclDfltOpt*)(buf.ary_elems+index)) :  NULL;
16692            }
16693            break;
16694            case 9:
16695            {
16696                fasttest::SclNone &msg = *new(ary_AllocN(buf,sizeof msg).elems) fasttest::SclNone;
16697                ok = SclNone_FastDecode(from,pmap,state,msg);
16698                ret = ok ? &Castbase(*(fasttest::SclNone*)(buf.ary_elems+index)) :  NULL;
16699            }
16700            break;
16701            case 10:
16702            {
16703                fasttest::SclNoneOpt &msg = *new(ary_AllocN(buf,sizeof msg).elems) fasttest::SclNoneOpt;
16704                ok = SclNoneOpt_FastDecode(from,pmap,state,msg);
16705                ret = ok ? &Castbase(*(fasttest::SclNoneOpt*)(buf.ary_elems+index)) :  NULL;
16706            }
16707            break;
16708            case 135:
16709            {
16710                ary_RemoveAll(lib_fast::_db.varlen);
16711                fasttest::SeqOrder &msg = *new(ary_AllocN(buf,sizeof msg).elems) fasttest::SeqOrder;
16712                ok = SeqOrder_FastDecode(from,pmap,state,msg);
16713                msg.length += ary_N(lib_fast::_db.varlen);
16714                ary_Addary(buf,ary_Getary(lib_fast::_db.varlen));
16715                ary_RemoveAll(lib_fast::_db.varlen);
16716                ret = ok ? &Castbase(*(fasttest::SeqOrder*)(buf.ary_elems+index)) :  NULL;
16717            }
16718            break;
16719            case 118:
16720            {
16721                ary_RemoveAll(lib_fast::_db.varlen);
16722                fasttest::SeqSgmOpt &msg = *new(ary_AllocN(buf,sizeof msg).elems) fasttest::SeqSgmOpt;
16723                ok = SeqSgmOpt_FastDecode(from,pmap,state,msg);
16724                msg.length += ary_N(lib_fast::_db.varlen);
16725                ary_Addary(buf,ary_Getary(lib_fast::_db.varlen));
16726                ary_RemoveAll(lib_fast::_db.varlen);
16727                ret = ok ? &Castbase(*(fasttest::SeqSgmOpt*)(buf.ary_elems+index)) :  NULL;
16728            }
16729            break;
16730            case 116:
16731            {
16732                ary_RemoveAll(lib_fast::_db.varlen);
16733                fasttest::SeqTrv &msg = *new(ary_AllocN(buf,sizeof msg).elems) fasttest::SeqTrv;
16734                ok = SeqTrv_FastDecode(from,pmap,state,msg);
16735                msg.length += ary_N(lib_fast::_db.varlen);
16736                ary_Addary(buf,ary_Getary(lib_fast::_db.varlen));
16737                ary_RemoveAll(lib_fast::_db.varlen);
16738                ret = ok ? &Castbase(*(fasttest::SeqTrv*)(buf.ary_elems+index)) :  NULL;
16739            }
16740            break;
16741            case 131:
16742            {
16743                fasttest::SeqTrvLenConst &msg = *new(ary_AllocN(buf,sizeof msg).elems) fasttest::SeqTrvLenConst;
16744                ok = SeqTrvLenConst_FastDecode(from,pmap,state,msg);
16745                ret = ok ? &Castbase(*(fasttest::SeqTrvLenConst*)(buf.ary_elems+index)) :  NULL;
16746            }
16747            break;
16748            case 132:
16749            {
16750                fasttest::SeqTrvLenConstOpt &msg = *new(ary_AllocN(buf,sizeof msg).elems) fasttest::SeqTrvLenConstOpt;
16751                ok = SeqTrvLenConstOpt_FastDecode(from,pmap,state,msg);
16752                ret = ok ? &Castbase(*(fasttest::SeqTrvLenConstOpt*)(buf.ary_elems+index)) :  NULL;
16753            }
16754            break;
16755            case 133:
16756            {
16757                ary_RemoveAll(lib_fast::_db.varlen);
16758                fasttest::SeqTrvLenDflt &msg = *new(ary_AllocN(buf,sizeof msg).elems) fasttest::SeqTrvLenDflt;
16759                ok = SeqTrvLenDflt_FastDecode(from,pmap,state,msg);
16760                msg.length += ary_N(lib_fast::_db.varlen);
16761                ary_Addary(buf,ary_Getary(lib_fast::_db.varlen));
16762                ary_RemoveAll(lib_fast::_db.varlen);
16763                ret = ok ? &Castbase(*(fasttest::SeqTrvLenDflt*)(buf.ary_elems+index)) :  NULL;
16764            }
16765            break;
16766            case 134:
16767            {
16768                ary_RemoveAll(lib_fast::_db.varlen);
16769                fasttest::SeqTrvLenDfltOpt &msg = *new(ary_AllocN(buf,sizeof msg).elems) fasttest::SeqTrvLenDfltOpt;
16770                ok = SeqTrvLenDfltOpt_FastDecode(from,pmap,state,msg);
16771                msg.length += ary_N(lib_fast::_db.varlen);
16772                ary_Addary(buf,ary_Getary(lib_fast::_db.varlen));
16773                ary_RemoveAll(lib_fast::_db.varlen);
16774                ret = ok ? &Castbase(*(fasttest::SeqTrvLenDfltOpt*)(buf.ary_elems+index)) :  NULL;
16775            }
16776            break;
16777            case 129:
16778            {
16779                ary_RemoveAll(lib_fast::_db.varlen);
16780                fasttest::SeqTrvLenNone &msg = *new(ary_AllocN(buf,sizeof msg).elems) fasttest::SeqTrvLenNone;
16781                ok = SeqTrvLenNone_FastDecode(from,pmap,state,msg);
16782                msg.length += ary_N(lib_fast::_db.varlen);
16783                ary_Addary(buf,ary_Getary(lib_fast::_db.varlen));
16784                ary_RemoveAll(lib_fast::_db.varlen);
16785                ret = ok ? &Castbase(*(fasttest::SeqTrvLenNone*)(buf.ary_elems+index)) :  NULL;
16786            }
16787            break;
16788            case 130:
16789            {
16790                ary_RemoveAll(lib_fast::_db.varlen);
16791                fasttest::SeqTrvLenNoneOpt &msg = *new(ary_AllocN(buf,sizeof msg).elems) fasttest::SeqTrvLenNoneOpt;
16792                ok = SeqTrvLenNoneOpt_FastDecode(from,pmap,state,msg);
16793                msg.length += ary_N(lib_fast::_db.varlen);
16794                ary_Addary(buf,ary_Getary(lib_fast::_db.varlen));
16795                ary_RemoveAll(lib_fast::_db.varlen);
16796                ret = ok ? &Castbase(*(fasttest::SeqTrvLenNoneOpt*)(buf.ary_elems+index)) :  NULL;
16797            }
16798            break;
16799            case 117:
16800            {
16801                ary_RemoveAll(lib_fast::_db.varlen);
16802                fasttest::SeqTrvOpt &msg = *new(ary_AllocN(buf,sizeof msg).elems) fasttest::SeqTrvOpt;
16803                ok = SeqTrvOpt_FastDecode(from,pmap,state,msg);
16804                msg.length += ary_N(lib_fast::_db.varlen);
16805                ary_Addary(buf,ary_Getary(lib_fast::_db.varlen));
16806                ary_RemoveAll(lib_fast::_db.varlen);
16807                ret = ok ? &Castbase(*(fasttest::SeqTrvOpt*)(buf.ary_elems+index)) :  NULL;
16808            }
16809            break;
16810            case 21:
16811            {
16812                fasttest::StrConst &msg = *new(ary_AllocN(buf,sizeof msg).elems) fasttest::StrConst;
16813                ok = StrConst_FastDecode(from,pmap,state,msg);
16814                ret = ok ? &Castbase(*(fasttest::StrConst*)(buf.ary_elems+index)) :  NULL;
16815            }
16816            break;
16817            case 22:
16818            {
16819                fasttest::StrConstOpt &msg = *new(ary_AllocN(buf,sizeof msg).elems) fasttest::StrConstOpt;
16820                ok = StrConstOpt_FastDecode(from,pmap,state,msg);
16821                ret = ok ? &Castbase(*(fasttest::StrConstOpt*)(buf.ary_elems+index)) :  NULL;
16822            }
16823            break;
16824            case 55:
16825            {
16826                fasttest::StrCopy &msg = *new(ary_AllocN(buf,sizeof msg).elems) fasttest::StrCopy;
16827                ok = StrCopy_FastDecode(from,pmap,state,msg);
16828                ret = ok ? &Castbase(*(fasttest::StrCopy*)(buf.ary_elems+index)) :  NULL;
16829            }
16830            break;
16831            case 57:
16832            {
16833                fasttest::StrCopyNull &msg = *new(ary_AllocN(buf,sizeof msg).elems) fasttest::StrCopyNull;
16834                ok = StrCopyNull_FastDecode(from,pmap,state,msg);
16835                ret = ok ? &Castbase(*(fasttest::StrCopyNull*)(buf.ary_elems+index)) :  NULL;
16836            }
16837            break;
16838            case 56:
16839            {
16840                fasttest::StrCopyOpt &msg = *new(ary_AllocN(buf,sizeof msg).elems) fasttest::StrCopyOpt;
16841                ok = StrCopyOpt_FastDecode(from,pmap,state,msg);
16842                ret = ok ? &Castbase(*(fasttest::StrCopyOpt*)(buf.ary_elems+index)) :  NULL;
16843            }
16844            break;
16845            case 39:
16846            {
16847                fasttest::StrDflt &msg = *new(ary_AllocN(buf,sizeof msg).elems) fasttest::StrDflt;
16848                ok = StrDflt_FastDecode(from,pmap,state,msg);
16849                ret = ok ? &Castbase(*(fasttest::StrDflt*)(buf.ary_elems+index)) :  NULL;
16850            }
16851            break;
16852            case 41:
16853            {
16854                fasttest::StrDfltNull &msg = *new(ary_AllocN(buf,sizeof msg).elems) fasttest::StrDfltNull;
16855                ok = StrDfltNull_FastDecode(from,pmap,state,msg);
16856                ret = ok ? &Castbase(*(fasttest::StrDfltNull*)(buf.ary_elems+index)) :  NULL;
16857            }
16858            break;
16859            case 40:
16860            {
16861                fasttest::StrDfltOpt &msg = *new(ary_AllocN(buf,sizeof msg).elems) fasttest::StrDfltOpt;
16862                ok = StrDfltOpt_FastDecode(from,pmap,state,msg);
16863                ret = ok ? &Castbase(*(fasttest::StrDfltOpt*)(buf.ary_elems+index)) :  NULL;
16864            }
16865            break;
16866            case 5:
16867            {
16868                fasttest::StrNone &msg = *new(ary_AllocN(buf,sizeof msg).elems) fasttest::StrNone;
16869                ok = StrNone_FastDecode(from,pmap,state,msg);
16870                ret = ok ? &Castbase(*(fasttest::StrNone*)(buf.ary_elems+index)) :  NULL;
16871            }
16872            break;
16873            case 6:
16874            {
16875                fasttest::StrNoneOpt &msg = *new(ary_AllocN(buf,sizeof msg).elems) fasttest::StrNoneOpt;
16876                ok = StrNoneOpt_FastDecode(from,pmap,state,msg);
16877                ret = ok ? &Castbase(*(fasttest::StrNoneOpt*)(buf.ary_elems+index)) :  NULL;
16878            }
16879            break;
16880            case 19:
16881            {
16882                fasttest::U32Const &msg = *new(ary_AllocN(buf,sizeof msg).elems) fasttest::U32Const;
16883                ok = U32Const_FastDecode(from,pmap,state,msg);
16884                ret = ok ? &Castbase(*(fasttest::U32Const*)(buf.ary_elems+index)) :  NULL;
16885            }
16886            break;
16887            case 20:
16888            {
16889                fasttest::U32ConstOpt &msg = *new(ary_AllocN(buf,sizeof msg).elems) fasttest::U32ConstOpt;
16890                ok = U32ConstOpt_FastDecode(from,pmap,state,msg);
16891                ret = ok ? &Castbase(*(fasttest::U32ConstOpt*)(buf.ary_elems+index)) :  NULL;
16892            }
16893            break;
16894            case 52:
16895            {
16896                fasttest::U32Copy &msg = *new(ary_AllocN(buf,sizeof msg).elems) fasttest::U32Copy;
16897                ok = U32Copy_FastDecode(from,pmap,state,msg);
16898                ret = ok ? &Castbase(*(fasttest::U32Copy*)(buf.ary_elems+index)) :  NULL;
16899            }
16900            break;
16901            case 54:
16902            {
16903                fasttest::U32CopyNull &msg = *new(ary_AllocN(buf,sizeof msg).elems) fasttest::U32CopyNull;
16904                ok = U32CopyNull_FastDecode(from,pmap,state,msg);
16905                ret = ok ? &Castbase(*(fasttest::U32CopyNull*)(buf.ary_elems+index)) :  NULL;
16906            }
16907            break;
16908            case 53:
16909            {
16910                fasttest::U32CopyOpt &msg = *new(ary_AllocN(buf,sizeof msg).elems) fasttest::U32CopyOpt;
16911                ok = U32CopyOpt_FastDecode(from,pmap,state,msg);
16912                ret = ok ? &Castbase(*(fasttest::U32CopyOpt*)(buf.ary_elems+index)) :  NULL;
16913            }
16914            break;
16915            case 69:
16916            {
16917                fasttest::U32Delta &msg = *new(ary_AllocN(buf,sizeof msg).elems) fasttest::U32Delta;
16918                ok = U32Delta_FastDecode(from,pmap,state,msg);
16919                ret = ok ? &Castbase(*(fasttest::U32Delta*)(buf.ary_elems+index)) :  NULL;
16920            }
16921            break;
16922            case 70:
16923            {
16924                fasttest::U32DeltaImpl &msg = *new(ary_AllocN(buf,sizeof msg).elems) fasttest::U32DeltaImpl;
16925                ok = U32DeltaImpl_FastDecode(from,pmap,state,msg);
16926                ret = ok ? &Castbase(*(fasttest::U32DeltaImpl*)(buf.ary_elems+index)) :  NULL;
16927            }
16928            break;
16929            case 72:
16930            {
16931                fasttest::U32DeltaNull &msg = *new(ary_AllocN(buf,sizeof msg).elems) fasttest::U32DeltaNull;
16932                ok = U32DeltaNull_FastDecode(from,pmap,state,msg);
16933                ret = ok ? &Castbase(*(fasttest::U32DeltaNull*)(buf.ary_elems+index)) :  NULL;
16934            }
16935            break;
16936            case 71:
16937            {
16938                fasttest::U32DeltaOpt &msg = *new(ary_AllocN(buf,sizeof msg).elems) fasttest::U32DeltaOpt;
16939                ok = U32DeltaOpt_FastDecode(from,pmap,state,msg);
16940                ret = ok ? &Castbase(*(fasttest::U32DeltaOpt*)(buf.ary_elems+index)) :  NULL;
16941            }
16942            break;
16943            case 36:
16944            {
16945                fasttest::U32Dflt &msg = *new(ary_AllocN(buf,sizeof msg).elems) fasttest::U32Dflt;
16946                ok = U32Dflt_FastDecode(from,pmap,state,msg);
16947                ret = ok ? &Castbase(*(fasttest::U32Dflt*)(buf.ary_elems+index)) :  NULL;
16948            }
16949            break;
16950            case 38:
16951            {
16952                fasttest::U32DfltNull &msg = *new(ary_AllocN(buf,sizeof msg).elems) fasttest::U32DfltNull;
16953                ok = U32DfltNull_FastDecode(from,pmap,state,msg);
16954                ret = ok ? &Castbase(*(fasttest::U32DfltNull*)(buf.ary_elems+index)) :  NULL;
16955            }
16956            break;
16957            case 37:
16958            {
16959                fasttest::U32DfltOpt &msg = *new(ary_AllocN(buf,sizeof msg).elems) fasttest::U32DfltOpt;
16960                ok = U32DfltOpt_FastDecode(from,pmap,state,msg);
16961                ret = ok ? &Castbase(*(fasttest::U32DfltOpt*)(buf.ary_elems+index)) :  NULL;
16962            }
16963            break;
16964            case 101:
16965            {
16966                fasttest::U32Incr &msg = *new(ary_AllocN(buf,sizeof msg).elems) fasttest::U32Incr;
16967                ok = U32Incr_FastDecode(from,pmap,state,msg);
16968                ret = ok ? &Castbase(*(fasttest::U32Incr*)(buf.ary_elems+index)) :  NULL;
16969            }
16970            break;
16971            case 102:
16972            {
16973                fasttest::U32IncrNV &msg = *new(ary_AllocN(buf,sizeof msg).elems) fasttest::U32IncrNV;
16974                ok = U32IncrNV_FastDecode(from,pmap,state,msg);
16975                ret = ok ? &Castbase(*(fasttest::U32IncrNV*)(buf.ary_elems+index)) :  NULL;
16976            }
16977            break;
16978            case 104:
16979            {
16980                fasttest::U32IncrNull &msg = *new(ary_AllocN(buf,sizeof msg).elems) fasttest::U32IncrNull;
16981                ok = U32IncrNull_FastDecode(from,pmap,state,msg);
16982                ret = ok ? &Castbase(*(fasttest::U32IncrNull*)(buf.ary_elems+index)) :  NULL;
16983            }
16984            break;
16985            case 103:
16986            {
16987                fasttest::U32IncrOpt &msg = *new(ary_AllocN(buf,sizeof msg).elems) fasttest::U32IncrOpt;
16988                ok = U32IncrOpt_FastDecode(from,pmap,state,msg);
16989                ret = ok ? &Castbase(*(fasttest::U32IncrOpt*)(buf.ary_elems+index)) :  NULL;
16990            }
16991            break;
16992            case 3:
16993            {
16994                fasttest::U32None &msg = *new(ary_AllocN(buf,sizeof msg).elems) fasttest::U32None;
16995                ok = U32None_FastDecode(from,pmap,state,msg);
16996                ret = ok ? &Castbase(*(fasttest::U32None*)(buf.ary_elems+index)) :  NULL;
16997            }
16998            break;
16999            case 4:
17000            {
17001                fasttest::U32NoneOpt &msg = *new(ary_AllocN(buf,sizeof msg).elems) fasttest::U32NoneOpt;
17002                ok = U32NoneOpt_FastDecode(from,pmap,state,msg);
17003                ret = ok ? &Castbase(*(fasttest::U32NoneOpt*)(buf.ary_elems+index)) :  NULL;
17004            }
17005            break;
17006            default:
17007            ok = false;
17008            state.error << "fasttest.TemplateHeader.id: unknown template " << tid << eol;
17009        }
17010    }
17011    return ret;
17012}
17013
17014// --- fasttest.TemplateHeaderMsgs..FixEncode
17015void fasttest::TemplateHeaderMsgs_FixEncode(cstring &buf, fasttest::TemplateHeader &header, char soh) {
17016    switch (header.id) {
17017        case 23:
17018        BVConst_FixEncode(buf,*fasttest::BVConst_Castdown(header),soh);
17019        break;
17020        case 24:
17021        BVConstOpt_FixEncode(buf,*fasttest::BVConstOpt_Castdown(header),soh);
17022        break;
17023        case 58:
17024        BVCopy_FixEncode(buf,*fasttest::BVCopy_Castdown(header),soh);
17025        break;
17026        case 60:
17027        BVCopyNull_FixEncode(buf,*fasttest::BVCopyNull_Castdown(header),soh);
17028        break;
17029        case 59:
17030        BVCopyOpt_FixEncode(buf,*fasttest::BVCopyOpt_Castdown(header),soh);
17031        break;
17032        case 42:
17033        BVDflt_FixEncode(buf,*fasttest::BVDflt_Castdown(header),soh);
17034        break;
17035        case 44:
17036        BVDfltNull_FixEncode(buf,*fasttest::BVDfltNull_Castdown(header),soh);
17037        break;
17038        case 43:
17039        BVDfltOpt_FixEncode(buf,*fasttest::BVDfltOpt_Castdown(header),soh);
17040        break;
17041        case 7:
17042        BVNone_FixEncode(buf,*fasttest::BVNone_Castdown(header),soh);
17043        break;
17044        case 8:
17045        BVNoneOpt_FixEncode(buf,*fasttest::BVNoneOpt_Castdown(header),soh);
17046        break;
17047        case 115:
17048        GroupSgmOpt_FixEncode(buf,*fasttest::GroupSgmOpt_Castdown(header),soh);
17049        break;
17050        case 113:
17051        GroupTrv_FixEncode(buf,*fasttest::GroupTrv_Castdown(header),soh);
17052        break;
17053        case 114:
17054        GroupTrvOpt_FixEncode(buf,*fasttest::GroupTrvOpt_Castdown(header),soh);
17055        break;
17056        case 17:
17057        I32Const_FixEncode(buf,*fasttest::I32Const_Castdown(header),soh);
17058        break;
17059        case 18:
17060        I32ConstOpt_FixEncode(buf,*fasttest::I32ConstOpt_Castdown(header),soh);
17061        break;
17062        case 49:
17063        I32Copy_FixEncode(buf,*fasttest::I32Copy_Castdown(header),soh);
17064        break;
17065        case 51:
17066        I32CopyNull_FixEncode(buf,*fasttest::I32CopyNull_Castdown(header),soh);
17067        break;
17068        case 50:
17069        I32CopyOpt_FixEncode(buf,*fasttest::I32CopyOpt_Castdown(header),soh);
17070        break;
17071        case 65:
17072        I32Delta_FixEncode(buf,*fasttest::I32Delta_Castdown(header),soh);
17073        break;
17074        case 66:
17075        I32DeltaImpl_FixEncode(buf,*fasttest::I32DeltaImpl_Castdown(header),soh);
17076        break;
17077        case 68:
17078        I32DeltaNull_FixEncode(buf,*fasttest::I32DeltaNull_Castdown(header),soh);
17079        break;
17080        case 67:
17081        I32DeltaOpt_FixEncode(buf,*fasttest::I32DeltaOpt_Castdown(header),soh);
17082        break;
17083        case 33:
17084        I32Dflt_FixEncode(buf,*fasttest::I32Dflt_Castdown(header),soh);
17085        break;
17086        case 35:
17087        I32DfltNull_FixEncode(buf,*fasttest::I32DfltNull_Castdown(header),soh);
17088        break;
17089        case 34:
17090        I32DfltOpt_FixEncode(buf,*fasttest::I32DfltOpt_Castdown(header),soh);
17091        break;
17092        case 97:
17093        I32Incr_FixEncode(buf,*fasttest::I32Incr_Castdown(header),soh);
17094        break;
17095        case 98:
17096        I32IncrNV_FixEncode(buf,*fasttest::I32IncrNV_Castdown(header),soh);
17097        break;
17098        case 100:
17099        I32IncrNull_FixEncode(buf,*fasttest::I32IncrNull_Castdown(header),soh);
17100        break;
17101        case 99:
17102        I32IncrOpt_FixEncode(buf,*fasttest::I32IncrOpt_Castdown(header),soh);
17103        break;
17104        case 1:
17105        I32None_FixEncode(buf,*fasttest::I32None_Castdown(header),soh);
17106        break;
17107        case 2:
17108        I32NoneOpt_FixEncode(buf,*fasttest::I32NoneOpt_Castdown(header),soh);
17109        break;
17110        case 151:
17111        MsgPmap_FixEncode(buf,*fasttest::MsgPmap_Castdown(header),soh);
17112        break;
17113        case 120:
17114        Reset_FixEncode(buf,*fasttest::Reset_Castdown(header),soh);
17115        break;
17116        case 145:
17117        SampleEnumConst_FixEncode(buf,*fasttest::SampleEnumConst_Castdown(header),soh);
17118        break;
17119        case 147:
17120        SampleEnumCopy_FixEncode(buf,*fasttest::SampleEnumCopy_Castdown(header),soh);
17121        break;
17122        case 146:
17123        SampleEnumDefault_FixEncode(buf,*fasttest::SampleEnumDefault_Castdown(header),soh);
17124        break;
17125        case 148:
17126        SampleSetConst_FixEncode(buf,*fasttest::SampleSetConst_Castdown(header),soh);
17127        break;
17128        case 150:
17129        SampleSetCopy_FixEncode(buf,*fasttest::SampleSetCopy_Castdown(header),soh);
17130        break;
17131        case 149:
17132        SampleSetDefault_FixEncode(buf,*fasttest::SampleSetDefault_Castdown(header),soh);
17133        break;
17134        case 25:
17135        SclConst_FixEncode(buf,*fasttest::SclConst_Castdown(header),soh);
17136        break;
17137        case 26:
17138        SclConstOpt_FixEncode(buf,*fasttest::SclConstOpt_Castdown(header),soh);
17139        break;
17140        case 61:
17141        SclCopy_FixEncode(buf,*fasttest::SclCopy_Castdown(header),soh);
17142        break;
17143        case 63:
17144        SclCopyNull_FixEncode(buf,*fasttest::SclCopyNull_Castdown(header),soh);
17145        break;
17146        case 62:
17147        SclCopyOpt_FixEncode(buf,*fasttest::SclCopyOpt_Castdown(header),soh);
17148        break;
17149        case 81:
17150        SclDelta_FixEncode(buf,*fasttest::SclDelta_Castdown(header),soh);
17151        break;
17152        case 82:
17153        SclDeltaImpl_FixEncode(buf,*fasttest::SclDeltaImpl_Castdown(header),soh);
17154        break;
17155        case 84:
17156        SclDeltaNull_FixEncode(buf,*fasttest::SclDeltaNull_Castdown(header),soh);
17157        break;
17158        case 83:
17159        SclDeltaOpt_FixEncode(buf,*fasttest::SclDeltaOpt_Castdown(header),soh);
17160        break;
17161        case 45:
17162        SclDflt_FixEncode(buf,*fasttest::SclDflt_Castdown(header),soh);
17163        break;
17164        case 47:
17165        SclDfltNull_FixEncode(buf,*fasttest::SclDfltNull_Castdown(header),soh);
17166        break;
17167        case 46:
17168        SclDfltOpt_FixEncode(buf,*fasttest::SclDfltOpt_Castdown(header),soh);
17169        break;
17170        case 9:
17171        SclNone_FixEncode(buf,*fasttest::SclNone_Castdown(header),soh);
17172        break;
17173        case 10:
17174        SclNoneOpt_FixEncode(buf,*fasttest::SclNoneOpt_Castdown(header),soh);
17175        break;
17176        case 135:
17177        SeqOrder_FixEncode(buf,*fasttest::SeqOrder_Castdown(header),soh);
17178        break;
17179        case 118:
17180        SeqSgmOpt_FixEncode(buf,*fasttest::SeqSgmOpt_Castdown(header),soh);
17181        break;
17182        case 116:
17183        SeqTrv_FixEncode(buf,*fasttest::SeqTrv_Castdown(header),soh);
17184        break;
17185        case 131:
17186        SeqTrvLenConst_FixEncode(buf,*fasttest::SeqTrvLenConst_Castdown(header),soh);
17187        break;
17188        case 132:
17189        SeqTrvLenConstOpt_FixEncode(buf,*fasttest::SeqTrvLenConstOpt_Castdown(header),soh);
17190        break;
17191        case 133:
17192        SeqTrvLenDflt_FixEncode(buf,*fasttest::SeqTrvLenDflt_Castdown(header),soh);
17193        break;
17194        case 134:
17195        SeqTrvLenDfltOpt_FixEncode(buf,*fasttest::SeqTrvLenDfltOpt_Castdown(header),soh);
17196        break;
17197        case 129:
17198        SeqTrvLenNone_FixEncode(buf,*fasttest::SeqTrvLenNone_Castdown(header),soh);
17199        break;
17200        case 130:
17201        SeqTrvLenNoneOpt_FixEncode(buf,*fasttest::SeqTrvLenNoneOpt_Castdown(header),soh);
17202        break;
17203        case 117:
17204        SeqTrvOpt_FixEncode(buf,*fasttest::SeqTrvOpt_Castdown(header),soh);
17205        break;
17206        case 21:
17207        StrConst_FixEncode(buf,*fasttest::StrConst_Castdown(header),soh);
17208        break;
17209        case 22:
17210        StrConstOpt_FixEncode(buf,*fasttest::StrConstOpt_Castdown(header),soh);
17211        break;
17212        case 55:
17213        StrCopy_FixEncode(buf,*fasttest::StrCopy_Castdown(header),soh);
17214        break;
17215        case 57:
17216        StrCopyNull_FixEncode(buf,*fasttest::StrCopyNull_Castdown(header),soh);
17217        break;
17218        case 56:
17219        StrCopyOpt_FixEncode(buf,*fasttest::StrCopyOpt_Castdown(header),soh);
17220        break;
17221        case 39:
17222        StrDflt_FixEncode(buf,*fasttest::StrDflt_Castdown(header),soh);
17223        break;
17224        case 41:
17225        StrDfltNull_FixEncode(buf,*fasttest::StrDfltNull_Castdown(header),soh);
17226        break;
17227        case 40:
17228        StrDfltOpt_FixEncode(buf,*fasttest::StrDfltOpt_Castdown(header),soh);
17229        break;
17230        case 5:
17231        StrNone_FixEncode(buf,*fasttest::StrNone_Castdown(header),soh);
17232        break;
17233        case 6:
17234        StrNoneOpt_FixEncode(buf,*fasttest::StrNoneOpt_Castdown(header),soh);
17235        break;
17236        case 19:
17237        U32Const_FixEncode(buf,*fasttest::U32Const_Castdown(header),soh);
17238        break;
17239        case 20:
17240        U32ConstOpt_FixEncode(buf,*fasttest::U32ConstOpt_Castdown(header),soh);
17241        break;
17242        case 52:
17243        U32Copy_FixEncode(buf,*fasttest::U32Copy_Castdown(header),soh);
17244        break;
17245        case 54:
17246        U32CopyNull_FixEncode(buf,*fasttest::U32CopyNull_Castdown(header),soh);
17247        break;
17248        case 53:
17249        U32CopyOpt_FixEncode(buf,*fasttest::U32CopyOpt_Castdown(header),soh);
17250        break;
17251        case 69:
17252        U32Delta_FixEncode(buf,*fasttest::U32Delta_Castdown(header),soh);
17253        break;
17254        case 70:
17255        U32DeltaImpl_FixEncode(buf,*fasttest::U32DeltaImpl_Castdown(header),soh);
17256        break;
17257        case 72:
17258        U32DeltaNull_FixEncode(buf,*fasttest::U32DeltaNull_Castdown(header),soh);
17259        break;
17260        case 71:
17261        U32DeltaOpt_FixEncode(buf,*fasttest::U32DeltaOpt_Castdown(header),soh);
17262        break;
17263        case 36:
17264        U32Dflt_FixEncode(buf,*fasttest::U32Dflt_Castdown(header),soh);
17265        break;
17266        case 38:
17267        U32DfltNull_FixEncode(buf,*fasttest::U32DfltNull_Castdown(header),soh);
17268        break;
17269        case 37:
17270        U32DfltOpt_FixEncode(buf,*fasttest::U32DfltOpt_Castdown(header),soh);
17271        break;
17272        case 101:
17273        U32Incr_FixEncode(buf,*fasttest::U32Incr_Castdown(header),soh);
17274        break;
17275        case 102:
17276        U32IncrNV_FixEncode(buf,*fasttest::U32IncrNV_Castdown(header),soh);
17277        break;
17278        case 104:
17279        U32IncrNull_FixEncode(buf,*fasttest::U32IncrNull_Castdown(header),soh);
17280        break;
17281        case 103:
17282        U32IncrOpt_FixEncode(buf,*fasttest::U32IncrOpt_Castdown(header),soh);
17283        break;
17284        case 3:
17285        U32None_FixEncode(buf,*fasttest::U32None_Castdown(header),soh);
17286        break;
17287        case 4:
17288        U32NoneOpt_FixEncode(buf,*fasttest::U32NoneOpt_Castdown(header),soh);
17289        break;
17290    }
17291}
17292
17293// --- fasttest.TemplateHeaderMsgs..Print
17294// Print message to STR. If message is too short for MSG_LEN, print nothing.
17295// MSG.LENGTH must have already been validated against msg_len.
17296// This function will additionally validate that sizeof(Msg) <= msg_len
17297bool fasttest::TemplateHeaderMsgs_Print(algo::cstring &str, fasttest::TemplateHeader &msg, u32 msg_len) {
17298    switch(msg.id) {
17299        case 23: {
17300            if (sizeof(fasttest::BVConst) > msg_len) { return false; }
17301            BVConst_Print((fasttest::BVConst&)(msg), str);
17302            return true;
17303        }
17304        case 24: {
17305            if (sizeof(fasttest::BVConstOpt) > msg_len) { return false; }
17306            BVConstOpt_Print((fasttest::BVConstOpt&)(msg), str);
17307            return true;
17308        }
17309        case 58: {
17310            if (sizeof(fasttest::BVCopy) > msg_len) { return false; }
17311            BVCopy_Print((fasttest::BVCopy&)(msg), str);
17312            return true;
17313        }
17314        case 60: {
17315            if (sizeof(fasttest::BVCopyNull) > msg_len) { return false; }
17316            BVCopyNull_Print((fasttest::BVCopyNull&)(msg), str);
17317            return true;
17318        }
17319        case 59: {
17320            if (sizeof(fasttest::BVCopyOpt) > msg_len) { return false; }
17321            BVCopyOpt_Print((fasttest::BVCopyOpt&)(msg), str);
17322            return true;
17323        }
17324        case 42: {
17325            if (sizeof(fasttest::BVDflt) > msg_len) { return false; }
17326            BVDflt_Print((fasttest::BVDflt&)(msg), str);
17327            return true;
17328        }
17329        case 44: {
17330            if (sizeof(fasttest::BVDfltNull) > msg_len) { return false; }
17331            BVDfltNull_Print((fasttest::BVDfltNull&)(msg), str);
17332            return true;
17333        }
17334        case 43: {
17335            if (sizeof(fasttest::BVDfltOpt) > msg_len) { return false; }
17336            BVDfltOpt_Print((fasttest::BVDfltOpt&)(msg), str);
17337            return true;
17338        }
17339        case 7: {
17340            if (sizeof(fasttest::BVNone) > msg_len) { return false; }
17341            BVNone_Print((fasttest::BVNone&)(msg), str);
17342            return true;
17343        }
17344        case 8: {
17345            if (sizeof(fasttest::BVNoneOpt) > msg_len) { return false; }
17346            BVNoneOpt_Print((fasttest::BVNoneOpt&)(msg), str);
17347            return true;
17348        }
17349        case 115: {
17350            if (sizeof(fasttest::GroupSgmOpt) > msg_len) { return false; }
17351            GroupSgmOpt_Print((fasttest::GroupSgmOpt&)(msg), str);
17352            return true;
17353        }
17354        case 113: {
17355            if (sizeof(fasttest::GroupTrv) > msg_len) { return false; }
17356            GroupTrv_Print((fasttest::GroupTrv&)(msg), str);
17357            return true;
17358        }
17359        case 114: {
17360            if (sizeof(fasttest::GroupTrvOpt) > msg_len) { return false; }
17361            GroupTrvOpt_Print((fasttest::GroupTrvOpt&)(msg), str);
17362            return true;
17363        }
17364        case 17: {
17365            if (sizeof(fasttest::I32Const) > msg_len) { return false; }
17366            I32Const_Print((fasttest::I32Const&)(msg), str);
17367            return true;
17368        }
17369        case 18: {
17370            if (sizeof(fasttest::I32ConstOpt) > msg_len) { return false; }
17371            I32ConstOpt_Print((fasttest::I32ConstOpt&)(msg), str);
17372            return true;
17373        }
17374        case 49: {
17375            if (sizeof(fasttest::I32Copy) > msg_len) { return false; }
17376            I32Copy_Print((fasttest::I32Copy&)(msg), str);
17377            return true;
17378        }
17379        case 51: {
17380            if (sizeof(fasttest::I32CopyNull) > msg_len) { return false; }
17381            I32CopyNull_Print((fasttest::I32CopyNull&)(msg), str);
17382            return true;
17383        }
17384        case 50: {
17385            if (sizeof(fasttest::I32CopyOpt) > msg_len) { return false; }
17386            I32CopyOpt_Print((fasttest::I32CopyOpt&)(msg), str);
17387            return true;
17388        }
17389        case 65: {
17390            if (sizeof(fasttest::I32Delta) > msg_len) { return false; }
17391            I32Delta_Print((fasttest::I32Delta&)(msg), str);
17392            return true;
17393        }
17394        case 66: {
17395            if (sizeof(fasttest::I32DeltaImpl) > msg_len) { return false; }
17396            I32DeltaImpl_Print((fasttest::I32DeltaImpl&)(msg), str);
17397            return true;
17398        }
17399        case 68: {
17400            if (sizeof(fasttest::I32DeltaNull) > msg_len) { return false; }
17401            I32DeltaNull_Print((fasttest::I32DeltaNull&)(msg), str);
17402            return true;
17403        }
17404        case 67: {
17405            if (sizeof(fasttest::I32DeltaOpt) > msg_len) { return false; }
17406            I32DeltaOpt_Print((fasttest::I32DeltaOpt&)(msg), str);
17407            return true;
17408        }
17409        case 33: {
17410            if (sizeof(fasttest::I32Dflt) > msg_len) { return false; }
17411            I32Dflt_Print((fasttest::I32Dflt&)(msg), str);
17412            return true;
17413        }
17414        case 35: {
17415            if (sizeof(fasttest::I32DfltNull) > msg_len) { return false; }
17416            I32DfltNull_Print((fasttest::I32DfltNull&)(msg), str);
17417            return true;
17418        }
17419        case 34: {
17420            if (sizeof(fasttest::I32DfltOpt) > msg_len) { return false; }
17421            I32DfltOpt_Print((fasttest::I32DfltOpt&)(msg), str);
17422            return true;
17423        }
17424        case 97: {
17425            if (sizeof(fasttest::I32Incr) > msg_len) { return false; }
17426            I32Incr_Print((fasttest::I32Incr&)(msg), str);
17427            return true;
17428        }
17429        case 98: {
17430            if (sizeof(fasttest::I32IncrNV) > msg_len) { return false; }
17431            I32IncrNV_Print((fasttest::I32IncrNV&)(msg), str);
17432            return true;
17433        }
17434        case 100: {
17435            if (sizeof(fasttest::I32IncrNull) > msg_len) { return false; }
17436            I32IncrNull_Print((fasttest::I32IncrNull&)(msg), str);
17437            return true;
17438        }
17439        case 99: {
17440            if (sizeof(fasttest::I32IncrOpt) > msg_len) { return false; }
17441            I32IncrOpt_Print((fasttest::I32IncrOpt&)(msg), str);
17442            return true;
17443        }
17444        case 1: {
17445            if (sizeof(fasttest::I32None) > msg_len) { return false; }
17446            I32None_Print((fasttest::I32None&)(msg), str);
17447            return true;
17448        }
17449        case 2: {
17450            if (sizeof(fasttest::I32NoneOpt) > msg_len) { return false; }
17451            I32NoneOpt_Print((fasttest::I32NoneOpt&)(msg), str);
17452            return true;
17453        }
17454        case 151: {
17455            if (sizeof(fasttest::MsgPmap) > msg_len) { return false; }
17456            MsgPmap_Print((fasttest::MsgPmap&)(msg), str);
17457            return true;
17458        }
17459        case 120: {
17460            if (sizeof(fasttest::Reset) > msg_len) { return false; }
17461            Reset_Print((fasttest::Reset&)(msg), str);
17462            return true;
17463        }
17464        case 145: {
17465            if (sizeof(fasttest::SampleEnumConst) > msg_len) { return false; }
17466            SampleEnumConst_Print((fasttest::SampleEnumConst&)(msg), str);
17467            return true;
17468        }
17469        case 147: {
17470            if (sizeof(fasttest::SampleEnumCopy) > msg_len) { return false; }
17471            SampleEnumCopy_Print((fasttest::SampleEnumCopy&)(msg), str);
17472            return true;
17473        }
17474        case 146: {
17475            if (sizeof(fasttest::SampleEnumDefault) > msg_len) { return false; }
17476            SampleEnumDefault_Print((fasttest::SampleEnumDefault&)(msg), str);
17477            return true;
17478        }
17479        case 148: {
17480            if (sizeof(fasttest::SampleSetConst) > msg_len) { return false; }
17481            SampleSetConst_Print((fasttest::SampleSetConst&)(msg), str);
17482            return true;
17483        }
17484        case 150: {
17485            if (sizeof(fasttest::SampleSetCopy) > msg_len) { return false; }
17486            SampleSetCopy_Print((fasttest::SampleSetCopy&)(msg), str);
17487            return true;
17488        }
17489        case 149: {
17490            if (sizeof(fasttest::SampleSetDefault) > msg_len) { return false; }
17491            SampleSetDefault_Print((fasttest::SampleSetDefault&)(msg), str);
17492            return true;
17493        }
17494        case 25: {
17495            if (sizeof(fasttest::SclConst) > msg_len) { return false; }
17496            SclConst_Print((fasttest::SclConst&)(msg), str);
17497            return true;
17498        }
17499        case 26: {
17500            if (sizeof(fasttest::SclConstOpt) > msg_len) { return false; }
17501            SclConstOpt_Print((fasttest::SclConstOpt&)(msg), str);
17502            return true;
17503        }
17504        case 61: {
17505            if (sizeof(fasttest::SclCopy) > msg_len) { return false; }
17506            SclCopy_Print((fasttest::SclCopy&)(msg), str);
17507            return true;
17508        }
17509        case 63: {
17510            if (sizeof(fasttest::SclCopyNull) > msg_len) { return false; }
17511            SclCopyNull_Print((fasttest::SclCopyNull&)(msg), str);
17512            return true;
17513        }
17514        case 62: {
17515            if (sizeof(fasttest::SclCopyOpt) > msg_len) { return false; }
17516            SclCopyOpt_Print((fasttest::SclCopyOpt&)(msg), str);
17517            return true;
17518        }
17519        case 81: {
17520            if (sizeof(fasttest::SclDelta) > msg_len) { return false; }
17521            SclDelta_Print((fasttest::SclDelta&)(msg), str);
17522            return true;
17523        }
17524        case 82: {
17525            if (sizeof(fasttest::SclDeltaImpl) > msg_len) { return false; }
17526            SclDeltaImpl_Print((fasttest::SclDeltaImpl&)(msg), str);
17527            return true;
17528        }
17529        case 84: {
17530            if (sizeof(fasttest::SclDeltaNull) > msg_len) { return false; }
17531            SclDeltaNull_Print((fasttest::SclDeltaNull&)(msg), str);
17532            return true;
17533        }
17534        case 83: {
17535            if (sizeof(fasttest::SclDeltaOpt) > msg_len) { return false; }
17536            SclDeltaOpt_Print((fasttest::SclDeltaOpt&)(msg), str);
17537            return true;
17538        }
17539        case 45: {
17540            if (sizeof(fasttest::SclDflt) > msg_len) { return false; }
17541            SclDflt_Print((fasttest::SclDflt&)(msg), str);
17542            return true;
17543        }
17544        case 47: {
17545            if (sizeof(fasttest::SclDfltNull) > msg_len) { return false; }
17546            SclDfltNull_Print((fasttest::SclDfltNull&)(msg), str);
17547            return true;
17548        }
17549        case 46: {
17550            if (sizeof(fasttest::SclDfltOpt) > msg_len) { return false; }
17551            SclDfltOpt_Print((fasttest::SclDfltOpt&)(msg), str);
17552            return true;
17553        }
17554        case 9: {
17555            if (sizeof(fasttest::SclNone) > msg_len) { return false; }
17556            SclNone_Print((fasttest::SclNone&)(msg), str);
17557            return true;
17558        }
17559        case 10: {
17560            if (sizeof(fasttest::SclNoneOpt) > msg_len) { return false; }
17561            SclNoneOpt_Print((fasttest::SclNoneOpt&)(msg), str);
17562            return true;
17563        }
17564        case 135: {
17565            if (sizeof(fasttest::SeqOrder) > msg_len) { return false; }
17566            SeqOrder_Print((fasttest::SeqOrder&)(msg), str);
17567            return true;
17568        }
17569        case 118: {
17570            if (sizeof(fasttest::SeqSgmOpt) > msg_len) { return false; }
17571            SeqSgmOpt_Print((fasttest::SeqSgmOpt&)(msg), str);
17572            return true;
17573        }
17574        case 116: {
17575            if (sizeof(fasttest::SeqTrv) > msg_len) { return false; }
17576            SeqTrv_Print((fasttest::SeqTrv&)(msg), str);
17577            return true;
17578        }
17579        case 131: {
17580            if (sizeof(fasttest::SeqTrvLenConst) > msg_len) { return false; }
17581            SeqTrvLenConst_Print((fasttest::SeqTrvLenConst&)(msg), str);
17582            return true;
17583        }
17584        case 132: {
17585            if (sizeof(fasttest::SeqTrvLenConstOpt) > msg_len) { return false; }
17586            SeqTrvLenConstOpt_Print((fasttest::SeqTrvLenConstOpt&)(msg), str);
17587            return true;
17588        }
17589        case 133: {
17590            if (sizeof(fasttest::SeqTrvLenDflt) > msg_len) { return false; }
17591            SeqTrvLenDflt_Print((fasttest::SeqTrvLenDflt&)(msg), str);
17592            return true;
17593        }
17594        case 134: {
17595            if (sizeof(fasttest::SeqTrvLenDfltOpt) > msg_len) { return false; }
17596            SeqTrvLenDfltOpt_Print((fasttest::SeqTrvLenDfltOpt&)(msg), str);
17597            return true;
17598        }
17599        case 129: {
17600            if (sizeof(fasttest::SeqTrvLenNone) > msg_len) { return false; }
17601            SeqTrvLenNone_Print((fasttest::SeqTrvLenNone&)(msg), str);
17602            return true;
17603        }
17604        case 130: {
17605            if (sizeof(fasttest::SeqTrvLenNoneOpt) > msg_len) { return false; }
17606            SeqTrvLenNoneOpt_Print((fasttest::SeqTrvLenNoneOpt&)(msg), str);
17607            return true;
17608        }
17609        case 117: {
17610            if (sizeof(fasttest::SeqTrvOpt) > msg_len) { return false; }
17611            SeqTrvOpt_Print((fasttest::SeqTrvOpt&)(msg), str);
17612            return true;
17613        }
17614        case 21: {
17615            if (sizeof(fasttest::StrConst) > msg_len) { return false; }
17616            StrConst_Print((fasttest::StrConst&)(msg), str);
17617            return true;
17618        }
17619        case 22: {
17620            if (sizeof(fasttest::StrConstOpt) > msg_len) { return false; }
17621            StrConstOpt_Print((fasttest::StrConstOpt&)(msg), str);
17622            return true;
17623        }
17624        case 55: {
17625            if (sizeof(fasttest::StrCopy) > msg_len) { return false; }
17626            StrCopy_Print((fasttest::StrCopy&)(msg), str);
17627            return true;
17628        }
17629        case 57: {
17630            if (sizeof(fasttest::StrCopyNull) > msg_len) { return false; }
17631            StrCopyNull_Print((fasttest::StrCopyNull&)(msg), str);
17632            return true;
17633        }
17634        case 56: {
17635            if (sizeof(fasttest::StrCopyOpt) > msg_len) { return false; }
17636            StrCopyOpt_Print((fasttest::StrCopyOpt&)(msg), str);
17637            return true;
17638        }
17639        case 39: {
17640            if (sizeof(fasttest::StrDflt) > msg_len) { return false; }
17641            StrDflt_Print((fasttest::StrDflt&)(msg), str);
17642            return true;
17643        }
17644        case 41: {
17645            if (sizeof(fasttest::StrDfltNull) > msg_len) { return false; }
17646            StrDfltNull_Print((fasttest::StrDfltNull&)(msg), str);
17647            return true;
17648        }
17649        case 40: {
17650            if (sizeof(fasttest::StrDfltOpt) > msg_len) { return false; }
17651            StrDfltOpt_Print((fasttest::StrDfltOpt&)(msg), str);
17652            return true;
17653        }
17654        case 5: {
17655            if (sizeof(fasttest::StrNone) > msg_len) { return false; }
17656            StrNone_Print((fasttest::StrNone&)(msg), str);
17657            return true;
17658        }
17659        case 6: {
17660            if (sizeof(fasttest::StrNoneOpt) > msg_len) { return false; }
17661            StrNoneOpt_Print((fasttest::StrNoneOpt&)(msg), str);
17662            return true;
17663        }
17664        case 19: {
17665            if (sizeof(fasttest::U32Const) > msg_len) { return false; }
17666            U32Const_Print((fasttest::U32Const&)(msg), str);
17667            return true;
17668        }
17669        case 20: {
17670            if (sizeof(fasttest::U32ConstOpt) > msg_len) { return false; }
17671            U32ConstOpt_Print((fasttest::U32ConstOpt&)(msg), str);
17672            return true;
17673        }
17674        case 52: {
17675            if (sizeof(fasttest::U32Copy) > msg_len) { return false; }
17676            U32Copy_Print((fasttest::U32Copy&)(msg), str);
17677            return true;
17678        }
17679        case 54: {
17680            if (sizeof(fasttest::U32CopyNull) > msg_len) { return false; }
17681            U32CopyNull_Print((fasttest::U32CopyNull&)(msg), str);
17682            return true;
17683        }
17684        case 53: {
17685            if (sizeof(fasttest::U32CopyOpt) > msg_len) { return false; }
17686            U32CopyOpt_Print((fasttest::U32CopyOpt&)(msg), str);
17687            return true;
17688        }
17689        case 69: {
17690            if (sizeof(fasttest::U32Delta) > msg_len) { return false; }
17691            U32Delta_Print((fasttest::U32Delta&)(msg), str);
17692            return true;
17693        }
17694        case 70: {
17695            if (sizeof(fasttest::U32DeltaImpl) > msg_len) { return false; }
17696            U32DeltaImpl_Print((fasttest::U32DeltaImpl&)(msg), str);
17697            return true;
17698        }
17699        case 72: {
17700            if (sizeof(fasttest::U32DeltaNull) > msg_len) { return false; }
17701            U32DeltaNull_Print((fasttest::U32DeltaNull&)(msg), str);
17702            return true;
17703        }
17704        case 71: {
17705            if (sizeof(fasttest::U32DeltaOpt) > msg_len) { return false; }
17706            U32DeltaOpt_Print((fasttest::U32DeltaOpt&)(msg), str);
17707            return true;
17708        }
17709        case 36: {
17710            if (sizeof(fasttest::U32Dflt) > msg_len) { return false; }
17711            U32Dflt_Print((fasttest::U32Dflt&)(msg), str);
17712            return true;
17713        }
17714        case 38: {
17715            if (sizeof(fasttest::U32DfltNull) > msg_len) { return false; }
17716            U32DfltNull_Print((fasttest::U32DfltNull&)(msg), str);
17717            return true;
17718        }
17719        case 37: {
17720            if (sizeof(fasttest::U32DfltOpt) > msg_len) { return false; }
17721            U32DfltOpt_Print((fasttest::U32DfltOpt&)(msg), str);
17722            return true;
17723        }
17724        case 101: {
17725            if (sizeof(fasttest::U32Incr) > msg_len) { return false; }
17726            U32Incr_Print((fasttest::U32Incr&)(msg), str);
17727            return true;
17728        }
17729        case 102: {
17730            if (sizeof(fasttest::U32IncrNV) > msg_len) { return false; }
17731            U32IncrNV_Print((fasttest::U32IncrNV&)(msg), str);
17732            return true;
17733        }
17734        case 104: {
17735            if (sizeof(fasttest::U32IncrNull) > msg_len) { return false; }
17736            U32IncrNull_Print((fasttest::U32IncrNull&)(msg), str);
17737            return true;
17738        }
17739        case 103: {
17740            if (sizeof(fasttest::U32IncrOpt) > msg_len) { return false; }
17741            U32IncrOpt_Print((fasttest::U32IncrOpt&)(msg), str);
17742            return true;
17743        }
17744        case 3: {
17745            if (sizeof(fasttest::U32None) > msg_len) { return false; }
17746            U32None_Print((fasttest::U32None&)(msg), str);
17747            return true;
17748        }
17749        case 4: {
17750            if (sizeof(fasttest::U32NoneOpt) > msg_len) { return false; }
17751            U32NoneOpt_Print((fasttest::U32NoneOpt&)(msg), str);
17752            return true;
17753        }
17754        default:
17755
17756        return false;
17757    }
17758}
17759
17760// --- fasttest.TemplateHeaderMsgs..ReadStrptr
17761// Parse ascii representation of message into binary, appending new data to BUF.
17762fasttest::TemplateHeaderMsgsCase fasttest::TemplateHeaderMsgs_ReadStrptr(algo::strptr str, algo::ByteAry &buf) {
17763    bool ok = false;
17764    tempstr msgtype_str;
17765    algo::StringIter iter(str);
17766    cstring_ReadCmdarg(msgtype_str, iter, false); // read first word
17767    fasttest::TemplateHeaderMsgsCase msgtype;
17768    value_SetStrptrMaybe(msgtype, msgtype_str); // map string -> enum
17769    switch (value_GetEnum(msgtype)) { // what message is it?
17770        case fasttest_TemplateHeaderMsgsCase_fasttest_BVConst: {
17771            int len = sizeof(fasttest::BVConst);
17772            fasttest::BVConst *ctype = new(ary_AllocN(buf, len).elems) fasttest::BVConst; // default values
17773            ok = BVConst_ReadStrptrMaybe(*ctype, str); // now read attributes
17774        } break; // fasttest::BVConst case
17775
17776        case fasttest_TemplateHeaderMsgsCase_fasttest_BVConstOpt: {
17777            int len = sizeof(fasttest::BVConstOpt);
17778            fasttest::BVConstOpt *ctype = new(ary_AllocN(buf, len).elems) fasttest::BVConstOpt; // default values
17779            ok = BVConstOpt_ReadStrptrMaybe(*ctype, str); // now read attributes
17780        } break; // fasttest::BVConstOpt case
17781
17782        case fasttest_TemplateHeaderMsgsCase_fasttest_BVCopy: {
17783            int len = sizeof(fasttest::BVCopy);
17784            fasttest::BVCopy *ctype = new(ary_AllocN(buf, len).elems) fasttest::BVCopy; // default values
17785            ok = BVCopy_ReadStrptrMaybe(*ctype, str); // now read attributes
17786        } break; // fasttest::BVCopy case
17787
17788        case fasttest_TemplateHeaderMsgsCase_fasttest_BVCopyNull: {
17789            int len = sizeof(fasttest::BVCopyNull);
17790            fasttest::BVCopyNull *ctype = new(ary_AllocN(buf, len).elems) fasttest::BVCopyNull; // default values
17791            ok = BVCopyNull_ReadStrptrMaybe(*ctype, str); // now read attributes
17792        } break; // fasttest::BVCopyNull case
17793
17794        case fasttest_TemplateHeaderMsgsCase_fasttest_BVCopyOpt: {
17795            int len = sizeof(fasttest::BVCopyOpt);
17796            fasttest::BVCopyOpt *ctype = new(ary_AllocN(buf, len).elems) fasttest::BVCopyOpt; // default values
17797            ok = BVCopyOpt_ReadStrptrMaybe(*ctype, str); // now read attributes
17798        } break; // fasttest::BVCopyOpt case
17799
17800        case fasttest_TemplateHeaderMsgsCase_fasttest_BVDflt: {
17801            int len = sizeof(fasttest::BVDflt);
17802            fasttest::BVDflt *ctype = new(ary_AllocN(buf, len).elems) fasttest::BVDflt; // default values
17803            ok = BVDflt_ReadStrptrMaybe(*ctype, str); // now read attributes
17804        } break; // fasttest::BVDflt case
17805
17806        case fasttest_TemplateHeaderMsgsCase_fasttest_BVDfltNull: {
17807            int len = sizeof(fasttest::BVDfltNull);
17808            fasttest::BVDfltNull *ctype = new(ary_AllocN(buf, len).elems) fasttest::BVDfltNull; // default values
17809            ok = BVDfltNull_ReadStrptrMaybe(*ctype, str); // now read attributes
17810        } break; // fasttest::BVDfltNull case
17811
17812        case fasttest_TemplateHeaderMsgsCase_fasttest_BVDfltOpt: {
17813            int len = sizeof(fasttest::BVDfltOpt);
17814            fasttest::BVDfltOpt *ctype = new(ary_AllocN(buf, len).elems) fasttest::BVDfltOpt; // default values
17815            ok = BVDfltOpt_ReadStrptrMaybe(*ctype, str); // now read attributes
17816        } break; // fasttest::BVDfltOpt case
17817
17818        case fasttest_TemplateHeaderMsgsCase_fasttest_BVNone: {
17819            int len = sizeof(fasttest::BVNone);
17820            fasttest::BVNone *ctype = new(ary_AllocN(buf, len).elems) fasttest::BVNone; // default values
17821            ok = BVNone_ReadStrptrMaybe(*ctype, str); // now read attributes
17822        } break; // fasttest::BVNone case
17823
17824        case fasttest_TemplateHeaderMsgsCase_fasttest_BVNoneOpt: {
17825            int len = sizeof(fasttest::BVNoneOpt);
17826            fasttest::BVNoneOpt *ctype = new(ary_AllocN(buf, len).elems) fasttest::BVNoneOpt; // default values
17827            ok = BVNoneOpt_ReadStrptrMaybe(*ctype, str); // now read attributes
17828        } break; // fasttest::BVNoneOpt case
17829
17830        case fasttest_TemplateHeaderMsgsCase_fasttest_GroupSgmOpt: {
17831            int len = sizeof(fasttest::GroupSgmOpt);
17832            fasttest::GroupSgmOpt *ctype = new(ary_AllocN(buf, len).elems) fasttest::GroupSgmOpt; // default values
17833            ok = GroupSgmOpt_ReadStrptrMaybe(*ctype, str); // now read attributes
17834        } break; // fasttest::GroupSgmOpt case
17835
17836        case fasttest_TemplateHeaderMsgsCase_fasttest_GroupTrv: {
17837            int len = sizeof(fasttest::GroupTrv);
17838            fasttest::GroupTrv *ctype = new(ary_AllocN(buf, len).elems) fasttest::GroupTrv; // default values
17839            ok = GroupTrv_ReadStrptrMaybe(*ctype, str); // now read attributes
17840        } break; // fasttest::GroupTrv case
17841
17842        case fasttest_TemplateHeaderMsgsCase_fasttest_GroupTrvOpt: {
17843            int len = sizeof(fasttest::GroupTrvOpt);
17844            fasttest::GroupTrvOpt *ctype = new(ary_AllocN(buf, len).elems) fasttest::GroupTrvOpt; // default values
17845            ok = GroupTrvOpt_ReadStrptrMaybe(*ctype, str); // now read attributes
17846        } break; // fasttest::GroupTrvOpt case
17847
17848        case fasttest_TemplateHeaderMsgsCase_fasttest_I32Const: {
17849            int len = sizeof(fasttest::I32Const);
17850            fasttest::I32Const *ctype = new(ary_AllocN(buf, len).elems) fasttest::I32Const; // default values
17851            ok = I32Const_ReadStrptrMaybe(*ctype, str); // now read attributes
17852        } break; // fasttest::I32Const case
17853
17854        case fasttest_TemplateHeaderMsgsCase_fasttest_I32ConstOpt: {
17855            int len = sizeof(fasttest::I32ConstOpt);
17856            fasttest::I32ConstOpt *ctype = new(ary_AllocN(buf, len).elems) fasttest::I32ConstOpt; // default values
17857            ok = I32ConstOpt_ReadStrptrMaybe(*ctype, str); // now read attributes
17858        } break; // fasttest::I32ConstOpt case
17859
17860        case fasttest_TemplateHeaderMsgsCase_fasttest_I32Copy: {
17861            int len = sizeof(fasttest::I32Copy);
17862            fasttest::I32Copy *ctype = new(ary_AllocN(buf, len).elems) fasttest::I32Copy; // default values
17863            ok = I32Copy_ReadStrptrMaybe(*ctype, str); // now read attributes
17864        } break; // fasttest::I32Copy case
17865
17866        case fasttest_TemplateHeaderMsgsCase_fasttest_I32CopyNull: {
17867            int len = sizeof(fasttest::I32CopyNull);
17868            fasttest::I32CopyNull *ctype = new(ary_AllocN(buf, len).elems) fasttest::I32CopyNull; // default values
17869            ok = I32CopyNull_ReadStrptrMaybe(*ctype, str); // now read attributes
17870        } break; // fasttest::I32CopyNull case
17871
17872        case fasttest_TemplateHeaderMsgsCase_fasttest_I32CopyOpt: {
17873            int len = sizeof(fasttest::I32CopyOpt);
17874            fasttest::I32CopyOpt *ctype = new(ary_AllocN(buf, len).elems) fasttest::I32CopyOpt; // default values
17875            ok = I32CopyOpt_ReadStrptrMaybe(*ctype, str); // now read attributes
17876        } break; // fasttest::I32CopyOpt case
17877
17878        case fasttest_TemplateHeaderMsgsCase_fasttest_I32Delta: {
17879            int len = sizeof(fasttest::I32Delta);
17880            fasttest::I32Delta *ctype = new(ary_AllocN(buf, len).elems) fasttest::I32Delta; // default values
17881            ok = I32Delta_ReadStrptrMaybe(*ctype, str); // now read attributes
17882        } break; // fasttest::I32Delta case
17883
17884        case fasttest_TemplateHeaderMsgsCase_fasttest_I32DeltaImpl: {
17885            int len = sizeof(fasttest::I32DeltaImpl);
17886            fasttest::I32DeltaImpl *ctype = new(ary_AllocN(buf, len).elems) fasttest::I32DeltaImpl; // default values
17887            ok = I32DeltaImpl_ReadStrptrMaybe(*ctype, str); // now read attributes
17888        } break; // fasttest::I32DeltaImpl case
17889
17890        case fasttest_TemplateHeaderMsgsCase_fasttest_I32DeltaNull: {
17891            int len = sizeof(fasttest::I32DeltaNull);
17892            fasttest::I32DeltaNull *ctype = new(ary_AllocN(buf, len).elems) fasttest::I32DeltaNull; // default values
17893            ok = I32DeltaNull_ReadStrptrMaybe(*ctype, str); // now read attributes
17894        } break; // fasttest::I32DeltaNull case
17895
17896        case fasttest_TemplateHeaderMsgsCase_fasttest_I32DeltaOpt: {
17897            int len = sizeof(fasttest::I32DeltaOpt);
17898            fasttest::I32DeltaOpt *ctype = new(ary_AllocN(buf, len).elems) fasttest::I32DeltaOpt; // default values
17899            ok = I32DeltaOpt_ReadStrptrMaybe(*ctype, str); // now read attributes
17900        } break; // fasttest::I32DeltaOpt case
17901
17902        case fasttest_TemplateHeaderMsgsCase_fasttest_I32Dflt: {
17903            int len = sizeof(fasttest::I32Dflt);
17904            fasttest::I32Dflt *ctype = new(ary_AllocN(buf, len).elems) fasttest::I32Dflt; // default values
17905            ok = I32Dflt_ReadStrptrMaybe(*ctype, str); // now read attributes
17906        } break; // fasttest::I32Dflt case
17907
17908        case fasttest_TemplateHeaderMsgsCase_fasttest_I32DfltNull: {
17909            int len = sizeof(fasttest::I32DfltNull);
17910            fasttest::I32DfltNull *ctype = new(ary_AllocN(buf, len).elems) fasttest::I32DfltNull; // default values
17911            ok = I32DfltNull_ReadStrptrMaybe(*ctype, str); // now read attributes
17912        } break; // fasttest::I32DfltNull case
17913
17914        case fasttest_TemplateHeaderMsgsCase_fasttest_I32DfltOpt: {
17915            int len = sizeof(fasttest::I32DfltOpt);
17916            fasttest::I32DfltOpt *ctype = new(ary_AllocN(buf, len).elems) fasttest::I32DfltOpt; // default values
17917            ok = I32DfltOpt_ReadStrptrMaybe(*ctype, str); // now read attributes
17918        } break; // fasttest::I32DfltOpt case
17919
17920        case fasttest_TemplateHeaderMsgsCase_fasttest_I32Incr: {
17921            int len = sizeof(fasttest::I32Incr);
17922            fasttest::I32Incr *ctype = new(ary_AllocN(buf, len).elems) fasttest::I32Incr; // default values
17923            ok = I32Incr_ReadStrptrMaybe(*ctype, str); // now read attributes
17924        } break; // fasttest::I32Incr case
17925
17926        case fasttest_TemplateHeaderMsgsCase_fasttest_I32IncrNV: {
17927            int len = sizeof(fasttest::I32IncrNV);
17928            fasttest::I32IncrNV *ctype = new(ary_AllocN(buf, len).elems) fasttest::I32IncrNV; // default values
17929            ok = I32IncrNV_ReadStrptrMaybe(*ctype, str); // now read attributes
17930        } break; // fasttest::I32IncrNV case
17931
17932        case fasttest_TemplateHeaderMsgsCase_fasttest_I32IncrNull: {
17933            int len = sizeof(fasttest::I32IncrNull);
17934            fasttest::I32IncrNull *ctype = new(ary_AllocN(buf, len).elems) fasttest::I32IncrNull; // default values
17935            ok = I32IncrNull_ReadStrptrMaybe(*ctype, str); // now read attributes
17936        } break; // fasttest::I32IncrNull case
17937
17938        case fasttest_TemplateHeaderMsgsCase_fasttest_I32IncrOpt: {
17939            int len = sizeof(fasttest::I32IncrOpt);
17940            fasttest::I32IncrOpt *ctype = new(ary_AllocN(buf, len).elems) fasttest::I32IncrOpt; // default values
17941            ok = I32IncrOpt_ReadStrptrMaybe(*ctype, str); // now read attributes
17942        } break; // fasttest::I32IncrOpt case
17943
17944        case fasttest_TemplateHeaderMsgsCase_fasttest_I32None: {
17945            int len = sizeof(fasttest::I32None);
17946            fasttest::I32None *ctype = new(ary_AllocN(buf, len).elems) fasttest::I32None; // default values
17947            ok = I32None_ReadStrptrMaybe(*ctype, str); // now read attributes
17948        } break; // fasttest::I32None case
17949
17950        case fasttest_TemplateHeaderMsgsCase_fasttest_I32NoneOpt: {
17951            int len = sizeof(fasttest::I32NoneOpt);
17952            fasttest::I32NoneOpt *ctype = new(ary_AllocN(buf, len).elems) fasttest::I32NoneOpt; // default values
17953            ok = I32NoneOpt_ReadStrptrMaybe(*ctype, str); // now read attributes
17954        } break; // fasttest::I32NoneOpt case
17955
17956        case fasttest_TemplateHeaderMsgsCase_fasttest_MsgPmap: {
17957            int len = sizeof(fasttest::MsgPmap);
17958            fasttest::MsgPmap *ctype = new(ary_AllocN(buf, len).elems) fasttest::MsgPmap; // default values
17959            ok = MsgPmap_ReadStrptrMaybe(*ctype, str); // now read attributes
17960        } break; // fasttest::MsgPmap case
17961
17962        case fasttest_TemplateHeaderMsgsCase_fasttest_Reset: {
17963            int len = sizeof(fasttest::Reset);
17964            fasttest::Reset *ctype = new(ary_AllocN(buf, len).elems) fasttest::Reset; // default values
17965            ok = Reset_ReadStrptrMaybe(*ctype, str); // now read attributes
17966        } break; // fasttest::Reset case
17967
17968        case fasttest_TemplateHeaderMsgsCase_fasttest_SampleEnumConst: {
17969            int len = sizeof(fasttest::SampleEnumConst);
17970            fasttest::SampleEnumConst *ctype = new(ary_AllocN(buf, len).elems) fasttest::SampleEnumConst; // default values
17971            ok = SampleEnumConst_ReadStrptrMaybe(*ctype, str); // now read attributes
17972        } break; // fasttest::SampleEnumConst case
17973
17974        case fasttest_TemplateHeaderMsgsCase_fasttest_SampleEnumCopy: {
17975            int len = sizeof(fasttest::SampleEnumCopy);
17976            fasttest::SampleEnumCopy *ctype = new(ary_AllocN(buf, len).elems) fasttest::SampleEnumCopy; // default values
17977            ok = SampleEnumCopy_ReadStrptrMaybe(*ctype, str); // now read attributes
17978        } break; // fasttest::SampleEnumCopy case
17979
17980        case fasttest_TemplateHeaderMsgsCase_fasttest_SampleEnumDefault: {
17981            int len = sizeof(fasttest::SampleEnumDefault);
17982            fasttest::SampleEnumDefault *ctype = new(ary_AllocN(buf, len).elems) fasttest::SampleEnumDefault; // default values
17983            ok = SampleEnumDefault_ReadStrptrMaybe(*ctype, str); // now read attributes
17984        } break; // fasttest::SampleEnumDefault case
17985
17986        case fasttest_TemplateHeaderMsgsCase_fasttest_SampleSetConst: {
17987            int len = sizeof(fasttest::SampleSetConst);
17988            fasttest::SampleSetConst *ctype = new(ary_AllocN(buf, len).elems) fasttest::SampleSetConst; // default values
17989            ok = SampleSetConst_ReadStrptrMaybe(*ctype, str); // now read attributes
17990        } break; // fasttest::SampleSetConst case
17991
17992        case fasttest_TemplateHeaderMsgsCase_fasttest_SampleSetCopy: {
17993            int len = sizeof(fasttest::SampleSetCopy);
17994            fasttest::SampleSetCopy *ctype = new(ary_AllocN(buf, len).elems) fasttest::SampleSetCopy; // default values
17995            ok = SampleSetCopy_ReadStrptrMaybe(*ctype, str); // now read attributes
17996        } break; // fasttest::SampleSetCopy case
17997
17998        case fasttest_TemplateHeaderMsgsCase_fasttest_SampleSetDefault: {
17999            int len = sizeof(fasttest::SampleSetDefault);
18000            fasttest::SampleSetDefault *ctype = new(ary_AllocN(buf, len).elems) fasttest::SampleSetDefault; // default values
18001            ok = SampleSetDefault_ReadStrptrMaybe(*ctype, str); // now read attributes
18002        } break; // fasttest::SampleSetDefault case
18003
18004        case fasttest_TemplateHeaderMsgsCase_fasttest_SclConst: {
18005            int len = sizeof(fasttest::SclConst);
18006            fasttest::SclConst *ctype = new(ary_AllocN(buf, len).elems) fasttest::SclConst; // default values
18007            ok = SclConst_ReadStrptrMaybe(*ctype, str); // now read attributes
18008        } break; // fasttest::SclConst case
18009
18010        case fasttest_TemplateHeaderMsgsCase_fasttest_SclConstOpt: {
18011            int len = sizeof(fasttest::SclConstOpt);
18012            fasttest::SclConstOpt *ctype = new(ary_AllocN(buf, len).elems) fasttest::SclConstOpt; // default values
18013            ok = SclConstOpt_ReadStrptrMaybe(*ctype, str); // now read attributes
18014        } break; // fasttest::SclConstOpt case
18015
18016        case fasttest_TemplateHeaderMsgsCase_fasttest_SclCopy: {
18017            int len = sizeof(fasttest::SclCopy);
18018            fasttest::SclCopy *ctype = new(ary_AllocN(buf, len).elems) fasttest::SclCopy; // default values
18019            ok = SclCopy_ReadStrptrMaybe(*ctype, str); // now read attributes
18020        } break; // fasttest::SclCopy case
18021
18022        case fasttest_TemplateHeaderMsgsCase_fasttest_SclCopyNull: {
18023            int len = sizeof(fasttest::SclCopyNull);
18024            fasttest::SclCopyNull *ctype = new(ary_AllocN(buf, len).elems) fasttest::SclCopyNull; // default values
18025            ok = SclCopyNull_ReadStrptrMaybe(*ctype, str); // now read attributes
18026        } break; // fasttest::SclCopyNull case
18027
18028        case fasttest_TemplateHeaderMsgsCase_fasttest_SclCopyOpt: {
18029            int len = sizeof(fasttest::SclCopyOpt);
18030            fasttest::SclCopyOpt *ctype = new(ary_AllocN(buf, len).elems) fasttest::SclCopyOpt; // default values
18031            ok = SclCopyOpt_ReadStrptrMaybe(*ctype, str); // now read attributes
18032        } break; // fasttest::SclCopyOpt case
18033
18034        case fasttest_TemplateHeaderMsgsCase_fasttest_SclDelta: {
18035            int len = sizeof(fasttest::SclDelta);
18036            fasttest::SclDelta *ctype = new(ary_AllocN(buf, len).elems) fasttest::SclDelta; // default values
18037            ok = SclDelta_ReadStrptrMaybe(*ctype, str); // now read attributes
18038        } break; // fasttest::SclDelta case
18039
18040        case fasttest_TemplateHeaderMsgsCase_fasttest_SclDeltaImpl: {
18041            int len = sizeof(fasttest::SclDeltaImpl);
18042            fasttest::SclDeltaImpl *ctype = new(ary_AllocN(buf, len).elems) fasttest::SclDeltaImpl; // default values
18043            ok = SclDeltaImpl_ReadStrptrMaybe(*ctype, str); // now read attributes
18044        } break; // fasttest::SclDeltaImpl case
18045
18046        case fasttest_TemplateHeaderMsgsCase_fasttest_SclDeltaNull: {
18047            int len = sizeof(fasttest::SclDeltaNull);
18048            fasttest::SclDeltaNull *ctype = new(ary_AllocN(buf, len).elems) fasttest::SclDeltaNull; // default values
18049            ok = SclDeltaNull_ReadStrptrMaybe(*ctype, str); // now read attributes
18050        } break; // fasttest::SclDeltaNull case
18051
18052        case fasttest_TemplateHeaderMsgsCase_fasttest_SclDeltaOpt: {
18053            int len = sizeof(fasttest::SclDeltaOpt);
18054            fasttest::SclDeltaOpt *ctype = new(ary_AllocN(buf, len).elems) fasttest::SclDeltaOpt; // default values
18055            ok = SclDeltaOpt_ReadStrptrMaybe(*ctype, str); // now read attributes
18056        } break; // fasttest::SclDeltaOpt case
18057
18058        case fasttest_TemplateHeaderMsgsCase_fasttest_SclDflt: {
18059            int len = sizeof(fasttest::SclDflt);
18060            fasttest::SclDflt *ctype = new(ary_AllocN(buf, len).elems) fasttest::SclDflt; // default values
18061            ok = SclDflt_ReadStrptrMaybe(*ctype, str); // now read attributes
18062        } break; // fasttest::SclDflt case
18063
18064        case fasttest_TemplateHeaderMsgsCase_fasttest_SclDfltNull: {
18065            int len = sizeof(fasttest::SclDfltNull);
18066            fasttest::SclDfltNull *ctype = new(ary_AllocN(buf, len).elems) fasttest::SclDfltNull; // default values
18067            ok = SclDfltNull_ReadStrptrMaybe(*ctype, str); // now read attributes
18068        } break; // fasttest::SclDfltNull case
18069
18070        case fasttest_TemplateHeaderMsgsCase_fasttest_SclDfltOpt: {
18071            int len = sizeof(fasttest::SclDfltOpt);
18072            fasttest::SclDfltOpt *ctype = new(ary_AllocN(buf, len).elems) fasttest::SclDfltOpt; // default values
18073            ok = SclDfltOpt_ReadStrptrMaybe(*ctype, str); // now read attributes
18074        } break; // fasttest::SclDfltOpt case
18075
18076        case fasttest_TemplateHeaderMsgsCase_fasttest_SclNone: {
18077            int len = sizeof(fasttest::SclNone);
18078            fasttest::SclNone *ctype = new(ary_AllocN(buf, len).elems) fasttest::SclNone; // default values
18079            ok = SclNone_ReadStrptrMaybe(*ctype, str); // now read attributes
18080        } break; // fasttest::SclNone case
18081
18082        case fasttest_TemplateHeaderMsgsCase_fasttest_SclNoneOpt: {
18083            int len = sizeof(fasttest::SclNoneOpt);
18084            fasttest::SclNoneOpt *ctype = new(ary_AllocN(buf, len).elems) fasttest::SclNoneOpt; // default values
18085            ok = SclNoneOpt_ReadStrptrMaybe(*ctype, str); // now read attributes
18086        } break; // fasttest::SclNoneOpt case
18087
18088        case fasttest_TemplateHeaderMsgsCase_fasttest_SeqOrder: {
18089            int len = sizeof(fasttest::SeqOrder);
18090            fasttest::SeqOrder *ctype = new(ary_AllocN(buf, len).elems) fasttest::SeqOrder; // default values
18091            algo::ByteAry varlenbuf;
18092            algo::ByteAry *varlenbuf_save = algo_lib::_db.varlenbuf;
18093            algo_lib::_db.varlenbuf = &varlenbuf;
18094            ok = SeqOrder_ReadStrptrMaybe(*ctype, str); // now read attributes
18095            len += ary_N(varlenbuf);
18096            ctype->length = u32(len);
18097            ary_Addary(buf, ary_Getary(varlenbuf));
18098            algo_lib::_db.varlenbuf = varlenbuf_save;
18099        } break; // fasttest::SeqOrder case
18100
18101        case fasttest_TemplateHeaderMsgsCase_fasttest_SeqSgmOpt: {
18102            int len = sizeof(fasttest::SeqSgmOpt);
18103            fasttest::SeqSgmOpt *ctype = new(ary_AllocN(buf, len).elems) fasttest::SeqSgmOpt; // default values
18104            algo::ByteAry varlenbuf;
18105            algo::ByteAry *varlenbuf_save = algo_lib::_db.varlenbuf;
18106            algo_lib::_db.varlenbuf = &varlenbuf;
18107            ok = SeqSgmOpt_ReadStrptrMaybe(*ctype, str); // now read attributes
18108            len += ary_N(varlenbuf);
18109            ctype->length = u32(len);
18110            ary_Addary(buf, ary_Getary(varlenbuf));
18111            algo_lib::_db.varlenbuf = varlenbuf_save;
18112        } break; // fasttest::SeqSgmOpt case
18113
18114        case fasttest_TemplateHeaderMsgsCase_fasttest_SeqTrv: {
18115            int len = sizeof(fasttest::SeqTrv);
18116            fasttest::SeqTrv *ctype = new(ary_AllocN(buf, len).elems) fasttest::SeqTrv; // default values
18117            algo::ByteAry varlenbuf;
18118            algo::ByteAry *varlenbuf_save = algo_lib::_db.varlenbuf;
18119            algo_lib::_db.varlenbuf = &varlenbuf;
18120            ok = SeqTrv_ReadStrptrMaybe(*ctype, str); // now read attributes
18121            len += ary_N(varlenbuf);
18122            ctype->length = u32(len);
18123            ary_Addary(buf, ary_Getary(varlenbuf));
18124            algo_lib::_db.varlenbuf = varlenbuf_save;
18125        } break; // fasttest::SeqTrv case
18126
18127        case fasttest_TemplateHeaderMsgsCase_fasttest_SeqTrvLenConst: {
18128            int len = sizeof(fasttest::SeqTrvLenConst);
18129            fasttest::SeqTrvLenConst *ctype = new(ary_AllocN(buf, len).elems) fasttest::SeqTrvLenConst; // default values
18130            ok = SeqTrvLenConst_ReadStrptrMaybe(*ctype, str); // now read attributes
18131        } break; // fasttest::SeqTrvLenConst case
18132
18133        case fasttest_TemplateHeaderMsgsCase_fasttest_SeqTrvLenConstOpt: {
18134            int len = sizeof(fasttest::SeqTrvLenConstOpt);
18135            fasttest::SeqTrvLenConstOpt *ctype = new(ary_AllocN(buf, len).elems) fasttest::SeqTrvLenConstOpt; // default values
18136            ok = SeqTrvLenConstOpt_ReadStrptrMaybe(*ctype, str); // now read attributes
18137        } break; // fasttest::SeqTrvLenConstOpt case
18138
18139        case fasttest_TemplateHeaderMsgsCase_fasttest_SeqTrvLenDflt: {
18140            int len = sizeof(fasttest::SeqTrvLenDflt);
18141            fasttest::SeqTrvLenDflt *ctype = new(ary_AllocN(buf, len).elems) fasttest::SeqTrvLenDflt; // default values
18142            algo::ByteAry varlenbuf;
18143            algo::ByteAry *varlenbuf_save = algo_lib::_db.varlenbuf;
18144            algo_lib::_db.varlenbuf = &varlenbuf;
18145            ok = SeqTrvLenDflt_ReadStrptrMaybe(*ctype, str); // now read attributes
18146            len += ary_N(varlenbuf);
18147            ctype->length = u32(len);
18148            ary_Addary(buf, ary_Getary(varlenbuf));
18149            algo_lib::_db.varlenbuf = varlenbuf_save;
18150        } break; // fasttest::SeqTrvLenDflt case
18151
18152        case fasttest_TemplateHeaderMsgsCase_fasttest_SeqTrvLenDfltOpt: {
18153            int len = sizeof(fasttest::SeqTrvLenDfltOpt);
18154            fasttest::SeqTrvLenDfltOpt *ctype = new(ary_AllocN(buf, len).elems) fasttest::SeqTrvLenDfltOpt; // default values
18155            algo::ByteAry varlenbuf;
18156            algo::ByteAry *varlenbuf_save = algo_lib::_db.varlenbuf;
18157            algo_lib::_db.varlenbuf = &varlenbuf;
18158            ok = SeqTrvLenDfltOpt_ReadStrptrMaybe(*ctype, str); // now read attributes
18159            len += ary_N(varlenbuf);
18160            ctype->length = u32(len);
18161            ary_Addary(buf, ary_Getary(varlenbuf));
18162            algo_lib::_db.varlenbuf = varlenbuf_save;
18163        } break; // fasttest::SeqTrvLenDfltOpt case
18164
18165        case fasttest_TemplateHeaderMsgsCase_fasttest_SeqTrvLenNone: {
18166            int len = sizeof(fasttest::SeqTrvLenNone);
18167            fasttest::SeqTrvLenNone *ctype = new(ary_AllocN(buf, len).elems) fasttest::SeqTrvLenNone; // default values
18168            algo::ByteAry varlenbuf;
18169            algo::ByteAry *varlenbuf_save = algo_lib::_db.varlenbuf;
18170            algo_lib::_db.varlenbuf = &varlenbuf;
18171            ok = SeqTrvLenNone_ReadStrptrMaybe(*ctype, str); // now read attributes
18172            len += ary_N(varlenbuf);
18173            ctype->length = u32(len);
18174            ary_Addary(buf, ary_Getary(varlenbuf));
18175            algo_lib::_db.varlenbuf = varlenbuf_save;
18176        } break; // fasttest::SeqTrvLenNone case
18177
18178        case fasttest_TemplateHeaderMsgsCase_fasttest_SeqTrvLenNoneOpt: {
18179            int len = sizeof(fasttest::SeqTrvLenNoneOpt);
18180            fasttest::SeqTrvLenNoneOpt *ctype = new(ary_AllocN(buf, len).elems) fasttest::SeqTrvLenNoneOpt; // default values
18181            algo::ByteAry varlenbuf;
18182            algo::ByteAry *varlenbuf_save = algo_lib::_db.varlenbuf;
18183            algo_lib::_db.varlenbuf = &varlenbuf;
18184            ok = SeqTrvLenNoneOpt_ReadStrptrMaybe(*ctype, str); // now read attributes
18185            len += ary_N(varlenbuf);
18186            ctype->length = u32(len);
18187            ary_Addary(buf, ary_Getary(varlenbuf));
18188            algo_lib::_db.varlenbuf = varlenbuf_save;
18189        } break; // fasttest::SeqTrvLenNoneOpt case
18190
18191        case fasttest_TemplateHeaderMsgsCase_fasttest_SeqTrvOpt: {
18192            int len = sizeof(fasttest::SeqTrvOpt);
18193            fasttest::SeqTrvOpt *ctype = new(ary_AllocN(buf, len).elems) fasttest::SeqTrvOpt; // default values
18194            algo::ByteAry varlenbuf;
18195            algo::ByteAry *varlenbuf_save = algo_lib::_db.varlenbuf;
18196            algo_lib::_db.varlenbuf = &varlenbuf;
18197            ok = SeqTrvOpt_ReadStrptrMaybe(*ctype, str); // now read attributes
18198            len += ary_N(varlenbuf);
18199            ctype->length = u32(len);
18200            ary_Addary(buf, ary_Getary(varlenbuf));
18201            algo_lib::_db.varlenbuf = varlenbuf_save;
18202        } break; // fasttest::SeqTrvOpt case
18203
18204        case fasttest_TemplateHeaderMsgsCase_fasttest_StrConst: {
18205            int len = sizeof(fasttest::StrConst);
18206            fasttest::StrConst *ctype = new(ary_AllocN(buf, len).elems) fasttest::StrConst; // default values
18207            ok = StrConst_ReadStrptrMaybe(*ctype, str); // now read attributes
18208        } break; // fasttest::StrConst case
18209
18210        case fasttest_TemplateHeaderMsgsCase_fasttest_StrConstOpt: {
18211            int len = sizeof(fasttest::StrConstOpt);
18212            fasttest::StrConstOpt *ctype = new(ary_AllocN(buf, len).elems) fasttest::StrConstOpt; // default values
18213            ok = StrConstOpt_ReadStrptrMaybe(*ctype, str); // now read attributes
18214        } break; // fasttest::StrConstOpt case
18215
18216        case fasttest_TemplateHeaderMsgsCase_fasttest_StrCopy: {
18217            int len = sizeof(fasttest::StrCopy);
18218            fasttest::StrCopy *ctype = new(ary_AllocN(buf, len).elems) fasttest::StrCopy; // default values
18219            ok = StrCopy_ReadStrptrMaybe(*ctype, str); // now read attributes
18220        } break; // fasttest::StrCopy case
18221
18222        case fasttest_TemplateHeaderMsgsCase_fasttest_StrCopyNull: {
18223            int len = sizeof(fasttest::StrCopyNull);
18224            fasttest::StrCopyNull *ctype = new(ary_AllocN(buf, len).elems) fasttest::StrCopyNull; // default values
18225            ok = StrCopyNull_ReadStrptrMaybe(*ctype, str); // now read attributes
18226        } break; // fasttest::StrCopyNull case
18227
18228        case fasttest_TemplateHeaderMsgsCase_fasttest_StrCopyOpt: {
18229            int len = sizeof(fasttest::StrCopyOpt);
18230            fasttest::StrCopyOpt *ctype = new(ary_AllocN(buf, len).elems) fasttest::StrCopyOpt; // default values
18231            ok = StrCopyOpt_ReadStrptrMaybe(*ctype, str); // now read attributes
18232        } break; // fasttest::StrCopyOpt case
18233
18234        case fasttest_TemplateHeaderMsgsCase_fasttest_StrDflt: {
18235            int len = sizeof(fasttest::StrDflt);
18236            fasttest::StrDflt *ctype = new(ary_AllocN(buf, len).elems) fasttest::StrDflt; // default values
18237            ok = StrDflt_ReadStrptrMaybe(*ctype, str); // now read attributes
18238        } break; // fasttest::StrDflt case
18239
18240        case fasttest_TemplateHeaderMsgsCase_fasttest_StrDfltNull: {
18241            int len = sizeof(fasttest::StrDfltNull);
18242            fasttest::StrDfltNull *ctype = new(ary_AllocN(buf, len).elems) fasttest::StrDfltNull; // default values
18243            ok = StrDfltNull_ReadStrptrMaybe(*ctype, str); // now read attributes
18244        } break; // fasttest::StrDfltNull case
18245
18246        case fasttest_TemplateHeaderMsgsCase_fasttest_StrDfltOpt: {
18247            int len = sizeof(fasttest::StrDfltOpt);
18248            fasttest::StrDfltOpt *ctype = new(ary_AllocN(buf, len).elems) fasttest::StrDfltOpt; // default values
18249            ok = StrDfltOpt_ReadStrptrMaybe(*ctype, str); // now read attributes
18250        } break; // fasttest::StrDfltOpt case
18251
18252        case fasttest_TemplateHeaderMsgsCase_fasttest_StrNone: {
18253            int len = sizeof(fasttest::StrNone);
18254            fasttest::StrNone *ctype = new(ary_AllocN(buf, len).elems) fasttest::StrNone; // default values
18255            ok = StrNone_ReadStrptrMaybe(*ctype, str); // now read attributes
18256        } break; // fasttest::StrNone case
18257
18258        case fasttest_TemplateHeaderMsgsCase_fasttest_StrNoneOpt: {
18259            int len = sizeof(fasttest::StrNoneOpt);
18260            fasttest::StrNoneOpt *ctype = new(ary_AllocN(buf, len).elems) fasttest::StrNoneOpt; // default values
18261            ok = StrNoneOpt_ReadStrptrMaybe(*ctype, str); // now read attributes
18262        } break; // fasttest::StrNoneOpt case
18263
18264        case fasttest_TemplateHeaderMsgsCase_fasttest_U32Const: {
18265            int len = sizeof(fasttest::U32Const);
18266            fasttest::U32Const *ctype = new(ary_AllocN(buf, len).elems) fasttest::U32Const; // default values
18267            ok = U32Const_ReadStrptrMaybe(*ctype, str); // now read attributes
18268        } break; // fasttest::U32Const case
18269
18270        case fasttest_TemplateHeaderMsgsCase_fasttest_U32ConstOpt: {
18271            int len = sizeof(fasttest::U32ConstOpt);
18272            fasttest::U32ConstOpt *ctype = new(ary_AllocN(buf, len).elems) fasttest::U32ConstOpt; // default values
18273            ok = U32ConstOpt_ReadStrptrMaybe(*ctype, str); // now read attributes
18274        } break; // fasttest::U32ConstOpt case
18275
18276        case fasttest_TemplateHeaderMsgsCase_fasttest_U32Copy: {
18277            int len = sizeof(fasttest::U32Copy);
18278            fasttest::U32Copy *ctype = new(ary_AllocN(buf, len).elems) fasttest::U32Copy; // default values
18279            ok = U32Copy_ReadStrptrMaybe(*ctype, str); // now read attributes
18280        } break; // fasttest::U32Copy case
18281
18282        case fasttest_TemplateHeaderMsgsCase_fasttest_U32CopyNull: {
18283            int len = sizeof(fasttest::U32CopyNull);
18284            fasttest::U32CopyNull *ctype = new(ary_AllocN(buf, len).elems) fasttest::U32CopyNull; // default values
18285            ok = U32CopyNull_ReadStrptrMaybe(*ctype, str); // now read attributes
18286        } break; // fasttest::U32CopyNull case
18287
18288        case fasttest_TemplateHeaderMsgsCase_fasttest_U32CopyOpt: {
18289            int len = sizeof(fasttest::U32CopyOpt);
18290            fasttest::U32CopyOpt *ctype = new(ary_AllocN(buf, len).elems) fasttest::U32CopyOpt; // default values
18291            ok = U32CopyOpt_ReadStrptrMaybe(*ctype, str); // now read attributes
18292        } break; // fasttest::U32CopyOpt case
18293
18294        case fasttest_TemplateHeaderMsgsCase_fasttest_U32Delta: {
18295            int len = sizeof(fasttest::U32Delta);
18296            fasttest::U32Delta *ctype = new(ary_AllocN(buf, len).elems) fasttest::U32Delta; // default values
18297            ok = U32Delta_ReadStrptrMaybe(*ctype, str); // now read attributes
18298        } break; // fasttest::U32Delta case
18299
18300        case fasttest_TemplateHeaderMsgsCase_fasttest_U32DeltaImpl: {
18301            int len = sizeof(fasttest::U32DeltaImpl);
18302            fasttest::U32DeltaImpl *ctype = new(ary_AllocN(buf, len).elems) fasttest::U32DeltaImpl; // default values
18303            ok = U32DeltaImpl_ReadStrptrMaybe(*ctype, str); // now read attributes
18304        } break; // fasttest::U32DeltaImpl case
18305
18306        case fasttest_TemplateHeaderMsgsCase_fasttest_U32DeltaNull: {
18307            int len = sizeof(fasttest::U32DeltaNull);
18308            fasttest::U32DeltaNull *ctype = new(ary_AllocN(buf, len).elems) fasttest::U32DeltaNull; // default values
18309            ok = U32DeltaNull_ReadStrptrMaybe(*ctype, str); // now read attributes
18310        } break; // fasttest::U32DeltaNull case
18311
18312        case fasttest_TemplateHeaderMsgsCase_fasttest_U32DeltaOpt: {
18313            int len = sizeof(fasttest::U32DeltaOpt);
18314            fasttest::U32DeltaOpt *ctype = new(ary_AllocN(buf, len).elems) fasttest::U32DeltaOpt; // default values
18315            ok = U32DeltaOpt_ReadStrptrMaybe(*ctype, str); // now read attributes
18316        } break; // fasttest::U32DeltaOpt case
18317
18318        case fasttest_TemplateHeaderMsgsCase_fasttest_U32Dflt: {
18319            int len = sizeof(fasttest::U32Dflt);
18320            fasttest::U32Dflt *ctype = new(ary_AllocN(buf, len).elems) fasttest::U32Dflt; // default values
18321            ok = U32Dflt_ReadStrptrMaybe(*ctype, str); // now read attributes
18322        } break; // fasttest::U32Dflt case
18323
18324        case fasttest_TemplateHeaderMsgsCase_fasttest_U32DfltNull: {
18325            int len = sizeof(fasttest::U32DfltNull);
18326            fasttest::U32DfltNull *ctype = new(ary_AllocN(buf, len).elems) fasttest::U32DfltNull; // default values
18327            ok = U32DfltNull_ReadStrptrMaybe(*ctype, str); // now read attributes
18328        } break; // fasttest::U32DfltNull case
18329
18330        case fasttest_TemplateHeaderMsgsCase_fasttest_U32DfltOpt: {
18331            int len = sizeof(fasttest::U32DfltOpt);
18332            fasttest::U32DfltOpt *ctype = new(ary_AllocN(buf, len).elems) fasttest::U32DfltOpt; // default values
18333            ok = U32DfltOpt_ReadStrptrMaybe(*ctype, str); // now read attributes
18334        } break; // fasttest::U32DfltOpt case
18335
18336        case fasttest_TemplateHeaderMsgsCase_fasttest_U32Incr: {
18337            int len = sizeof(fasttest::U32Incr);
18338            fasttest::U32Incr *ctype = new(ary_AllocN(buf, len).elems) fasttest::U32Incr; // default values
18339            ok = U32Incr_ReadStrptrMaybe(*ctype, str); // now read attributes
18340        } break; // fasttest::U32Incr case
18341
18342        case fasttest_TemplateHeaderMsgsCase_fasttest_U32IncrNV: {
18343            int len = sizeof(fasttest::U32IncrNV);
18344            fasttest::U32IncrNV *ctype = new(ary_AllocN(buf, len).elems) fasttest::U32IncrNV; // default values
18345            ok = U32IncrNV_ReadStrptrMaybe(*ctype, str); // now read attributes
18346        } break; // fasttest::U32IncrNV case
18347
18348        case fasttest_TemplateHeaderMsgsCase_fasttest_U32IncrNull: {
18349            int len = sizeof(fasttest::U32IncrNull);
18350            fasttest::U32IncrNull *ctype = new(ary_AllocN(buf, len).elems) fasttest::U32IncrNull; // default values
18351            ok = U32IncrNull_ReadStrptrMaybe(*ctype, str); // now read attributes
18352        } break; // fasttest::U32IncrNull case
18353
18354        case fasttest_TemplateHeaderMsgsCase_fasttest_U32IncrOpt: {
18355            int len = sizeof(fasttest::U32IncrOpt);
18356            fasttest::U32IncrOpt *ctype = new(ary_AllocN(buf, len).elems) fasttest::U32IncrOpt; // default values
18357            ok = U32IncrOpt_ReadStrptrMaybe(*ctype, str); // now read attributes
18358        } break; // fasttest::U32IncrOpt case
18359
18360        case fasttest_TemplateHeaderMsgsCase_fasttest_U32None: {
18361            int len = sizeof(fasttest::U32None);
18362            fasttest::U32None *ctype = new(ary_AllocN(buf, len).elems) fasttest::U32None; // default values
18363            ok = U32None_ReadStrptrMaybe(*ctype, str); // now read attributes
18364        } break; // fasttest::U32None case
18365
18366        case fasttest_TemplateHeaderMsgsCase_fasttest_U32NoneOpt: {
18367            int len = sizeof(fasttest::U32NoneOpt);
18368            fasttest::U32NoneOpt *ctype = new(ary_AllocN(buf, len).elems) fasttest::U32NoneOpt; // default values
18369            ok = U32NoneOpt_ReadStrptrMaybe(*ctype, str); // now read attributes
18370        } break; // fasttest::U32NoneOpt case
18371
18372        default: break;
18373    }
18374    return ok ? msgtype : fasttest::TemplateHeaderMsgsCase();
18375}
18376
18377// --- fasttest.TemplateHeaderMsgs..ReadStrptrMaybe
18378// Parse ascii representation of message into binary, appending new data to BUF.
18379bool fasttest::TemplateHeaderMsgs_ReadStrptrMaybe(algo::strptr str, algo::ByteAry &buf) {
18380    fasttest::TemplateHeaderMsgsCase msgtype = TemplateHeaderMsgs_ReadStrptr(str,buf);
18381    return !(msgtype == fasttest::TemplateHeaderMsgsCase());
18382}